src/plibc.c

Go to the documentation of this file.

/*
     This file is part of PlibC.
     (C) 2005 Nils Durner (and other contributing authors)

           This library is free software; you can redistribute it and/or
           modify it under the terms of the GNU Lesser General Public
           License as published by the Free Software Foundation; either
           version 2.1 of the License, or (at your option) any later version.
        
           This library 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
           Lesser General Public License for more details.
        
           You should have received a copy of the GNU Lesser General Public
           License along with this library; if not, write to the Free Software
           Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "plibc_private.h"

#define DEBUG_WINPROC 0

char szRootDir[_MAX_PATH + 1];
long lRootDirLen;
char szHomeDir[_MAX_PATH + 2];
long lHomeDirLen;
char szUser[261] = "";
char *_pszOrg = NULL, *_pszApp = NULL;
OSVERSIONINFO theWinVersion;
unsigned int uiSockCount = 0;
Winsock *pSocks;
HANDLE hSocksLock;
unsigned int uiMappingsCount = 0;
TMapping *pMappings;
HANDLE hMappingsLock;
TPanicProc __plibc_panic = NULL;
int iInit = 0;

static HINSTANCE hIphlpapi, hAdvapi;

BOOL __win_IsHandleMarkedAsBlocking(SOCKET hHandle)
{
  BOOL bBlocking;
  unsigned int uiIndex;

  bBlocking = TRUE;
  WaitForSingleObject(hSocksLock, INFINITE);
  for(uiIndex = 0; uiIndex <= uiSockCount; uiIndex++)
  {
    if (pSocks[uiIndex].s == hHandle)
    {
      bBlocking = pSocks[uiIndex].bBlocking;
      break;
    }
  }
  ReleaseMutex(hSocksLock);

  return bBlocking;
}

void __win_SetHandleBlockingMode(SOCKET s, BOOL bBlocking)
{
  unsigned int uiIndex = 0;
  int bFound = 0;

  WaitForSingleObject(hSocksLock, INFINITE);

  for(uiIndex = 0; uiIndex <= uiSockCount; uiIndex++)
  {
    if (pSocks[uiIndex].s == s)
    {
      bFound = 1;
      break;
    }
  }

  if (bFound)
    pSocks[uiIndex].bBlocking = bBlocking;
  else
  {
    uiIndex = 0;

    while(TRUE)
    {
      if (pSocks[uiIndex].s == -1)
      {
        pSocks[uiIndex].s = s;
        pSocks[uiIndex].bBlocking = bBlocking;
      }
      if (uiIndex == uiSockCount)
      {
        uiSockCount++;
        pSocks = (Winsock *) realloc(pSocks, (uiSockCount + 1) * sizeof(Winsock));
        pSocks[uiSockCount].s = -1;

        break;
      }
      uiIndex++;
    }
  }
  ReleaseMutex(hSocksLock);
}

void __win_DiscardHandleBlockingMode(SOCKET s)
{
  unsigned int uiIndex;

  WaitForSingleObject(hSocksLock, INFINITE);
  for(uiIndex = 0; uiIndex <= uiSockCount; uiIndex++)
    if (pSocks[uiIndex].s == s)
      pSocks[uiIndex].s = -1;
  ReleaseMutex(hSocksLock);
}

int _win_isSocketValid(int s)
{
  long l;
  return ioctlsocket(s, FIONREAD, &l) != SOCKET_ERROR && _get_osfhandle(s) == -1;
}

void __plibc_panic_default(int err, char *szMsg)
{
#if DEBUG_WINPROC
        if(err == INT_MAX)
                fputs(stderr, szMsg);
#endif
}

int plibc_init(char *pszOrg, char *pszApp)
{
  long lRet;
  WSADATA wsaData;
  enum {ROOT, USER, HOME} eAction = ROOT;
  UINT uiCP;
  char szLang[11] = "LANG=";
  LCID locale;

        if (iInit)
                return ERROR_SUCCESS;

        __plibc_panic = __plibc_panic_default;

  /* Init path translation */
  if((lRet = _plibc_DetermineRootDir()) == ERROR_SUCCESS)
  {
    DWORD dwSize = 261;

    eAction = USER;
    GetUserName(szUser, &dwSize);

    eAction = HOME;
    lRet = _plibc_DetermineHomeDir();
  }

  if(lRet != ERROR_SUCCESS)
  {
    char *pszMsg, *pszMsg2;
          char szPanic[1001];
          long lMem;

    lMem =
      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_SYSTEM |
                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL, lRet, 0,
                    (LPTSTR) & pszMsg, 0, NULL);

    pszMsg2 = (char *) malloc(lMem + 1);
    strcpy(pszMsg2, pszMsg);
    if(pszMsg2[lMem - 2] == '\r')
      pszMsg2[lMem - 2] = 0;

    _win_snprintf(szPanic, 1000, "Cannot determine %s (%s)\n",
            eAction == ROOT ? "root directory" :
              "home directory", pszMsg2);
    szPanic[1000] = 0;
    __plibc_panic(1, szPanic);
    
    LocalFree(pszMsg);
    free(pszMsg2);

    return lRet;
  }

  /* Init Winsock */
  if (WSAStartup(257, &wsaData) != 0)
  {
    __plibc_panic(2, "Cannot initialize Winsock");

    return GetLastError();
  }

  /* To keep track of blocking/non-blocking sockets */
  pSocks = (Winsock *) malloc(sizeof(Winsock) + (uiSockCount + 1));
  pSocks[0].s = -1;
  hSocksLock = CreateMutex(NULL, FALSE, NULL);

  /* To keep track of mapped files */
  pMappings = (TMapping *) malloc(sizeof(TMapping));
  pMappings[0].pStart = NULL;
  hMappingsLock = CreateMutex(NULL, FALSE, NULL);

  /* Open files in binary mode */
  _fmode = _O_BINARY;

  /* Get Windows version */
  theWinVersion.dwOSVersionInfoSize = sizeof(theWinVersion);
  GetVersionEx(&theWinVersion);

  /* Use ANSI codepage for console IO */
  uiCP = GetACP();
  SetConsoleCP(uiCP);
  SetConsoleOutputCP(uiCP);
  setlocale( LC_ALL, ".OCP" );

        /* Set LANG environment variable */
        locale = GetThreadLocale();
  GetLocaleInfo(locale, LOCALE_SISO3166CTRYNAME, szLang + 5, 3);
  szLang[7] = '_';
  GetLocaleInfo(locale, LOCALE_SISO639LANGNAME, szLang + 8, 3);
  putenv(szLang);

  /* Initialize COM library */
  CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
  
        _pszOrg = strdup(pszOrg);
        _pszApp = strdup(pszApp);
        
        iInit = 1;
        
        return ERROR_SUCCESS;
}

void plibc_shutdown()
{
        if (!iInit)
                return;
        
  WSACleanup();
  free(pSocks);
  CloseHandle(hSocksLock);

  free(pMappings);
  CloseHandle(hMappingsLock);

  FreeLibrary(hIphlpapi);
  FreeLibrary(hAdvapi);

  CoUninitialize();
  
  free(_pszOrg);
  free(_pszApp);
  
  iInit = 0;
}

void plibc_set_panic_proc(TPanicProc proc)
{
        __plibc_panic = proc;
}

int IsWinNT()
{
  return theWinVersion.dwPlatformId == VER_PLATFORM_WIN32_NT;
}

/* end of plibc.c */

---