---

OS.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <direct.h>
#include <errno.h>
#include <time.h>
#include <io.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "OSDependent/OS.h"
#include "Utilities/Resolver.h"

const char OS::DirectorySeparator  = '\\';
const char *OS::TemporaryDirectory = "C:\\Temp";
const char *OS::LineSeparator      = "\r\n";
/*
 * Get the hostname of this machine.
 * The returned value is statically allocated, so the user does 
 * not need to deallocate.  This value will not change, so we
 * are safe to use static memory.
 *
 * Returns name on success, NULL on failure.
 */
const char *
OS::getMyHostName()
{        
  static char namebuf[64];
  static char *name = NULL;

  if (name == NULL) {
    struct hostent *ent;
    int length = sizeof(namebuf);
    
    if (::GetComputerNameA(namebuf, (LPDWORD)&length) == 0)
      return NULL;
    ent = ::gethostbyname(namebuf);
    
    if (ent == NULL)
      return NULL;
    OS::strcpy(namebuf, ent->h_name);

    name = namebuf;
  }
  return name;
}


const char *
OS::getMyHostIPAddr()
{
    char name[128];

    if(gethostname (name,128)!=0)
        return NULL;

    struct      hostent * heptr;
        heptr = gethostbyname (name);

        
    if (heptr == NULL) 
                return NULL;

    return OS::strdup(inet_ntoa( *((struct in_addr*)heptr->h_addr)));
}


/*
 * Reentrant version of strtok.
 */
char *
OS::strtok_r(char *s, const char *tokens, char **lasts)
{
  if (s == NULL)
    s = *lasts;
  else
    *lasts = s;
  if (*s == '\0') 
    return NULL;
  char *end = s + strlen(s);
  s = ::strtok(s, tokens);
  if (s == NULL)
    return NULL;
  int l_sub = strlen(s);
  *lasts = s + l_sub;
  if (end != s + l_sub)
    *lasts += 1;
  return s;
}

int 
OS::stat(const char *name, stat_t *stat)
{
  return ::_stat(name, stat);
}


int
OS::remove(const char *name)
{
  if (::DeleteFile(__TEXT(name)) == FALSE)
    return -1;
  return 0;
}

int
OS::chdir(const char *name)
{
  return ::_chdir(name);
}

bool
OS::isDirectory(const char *name)
{
  DWORD attributes = ::GetFileAttributes(__TEXT(name));
        if (attributes == -1)
                return false;
  return (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0 ? false : true;
}

int
OS::mkdir(const char *name)
{
  // Check if directory already exists.  If not try to create it.
  if (isDirectory(name))
    return 0;
  if (::CreateDirectory(__TEXT(name), NULL) == FALSE)
    return -1;
  return 0;
}

int
OS::rmdir(const char *name)
{
  if (::RemoveDirectory(__TEXT(name)) == FALSE)
    return -1;
  return 0;
}

int
OS::rename(const char *src, const char *dst)
{
  if (::MoveFileEx(__TEXT(src), __TEXT(dst), MOVEFILE_REPLACE_EXISTING) == FALSE)
    return -1;
  return 0;
}

char *
OS::getProcessorName ()
{
  static char buf[512];
  OSVERSIONINFO osvi;
  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

  ::GetVersionEx (&osvi);

  switch(osvi.dwPlatformId) {
  case VER_PLATFORM_WIN32s:
  case VER_PLATFORM_WIN32_WINDOWS:
    OS::strcpy(buf,"windows");
    break;
  case VER_PLATFORM_WIN32_NT:
    OS::strcpy(buf,"windows-nt");
    break;
  default:
    OS::strcpy(buf,"windows-unknown");
    break;
  }
  
  return(buf);
}

const char *
OS::getUserName()
{
  static char username[64];
  unsigned long size = sizeof(username);
  ::GetUserName(username, &size);
  return username;
}

char *
OS::getOSName()
{
  static char buf[512];
  SYSTEM_INFO si;

  ::GetSystemInfo(&si);

  if (OS::strcmp(getProcessorName(), "windows-nt") == 0) {
    if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
      switch (si.wProcessorLevel) {
      case 3: 
        OS::strcpy(buf,"i386");
        break;
      case 4: 
        OS::strcpy(buf,"i486");
        break;
      case 5: 
        OS::strcpy(buf, "i586");
        break;
      default:        
        OS::strcpy(buf,"intel");
        break;
      }
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_MIPS) {
      OS::strcpy(buf,"mips");
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA) {
      OS::sprintf(buf, "Alpha%d", si.wProcessorLevel);
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_PPC) {
      OS::sprintf(buf, "PPC 6%02d", si.wProcessorLevel);
    }
  } else {
    if (si.dwProcessorType == PROCESSOR_INTEL_386) {
      OS::strcpy(buf,"i386");
    } else if (si.dwProcessorType == PROCESSOR_INTEL_486) {
      OS::strcpy(buf,"i486");
    } else if (si.dwProcessorType == PROCESSOR_INTEL_PENTIUM) {
      OS::strcpy(buf,"i586");
    } else OS::strcpy(buf,"intel");
  }

  return (buf);
}

/*
 * Convert the last error to errno.
 */
int
OS::getErrno()
{
  int val = 0;
  switch (GetLastError()) {
    case ERROR_INVALID_HANDLE:
      val = EISDIR;
      break;
    case ERROR_ACCESS_DENIED:
      val = EROFS;
      break;
    case ERROR_NOT_ENOUGH_MEMORY:
      val = ENOSPC;
      break;
    case ERROR_TOO_MANY_OPEN_FILES:
      val = EMFILE;
      break;
    case ERROR_BUFFER_OVERFLOW:
      val = ENAMETOOLONG;
      break;
    case ERROR_OUTOFMEMORY:
      val = ENOMEM;
      break;
    case ERROR_FILE_NOT_FOUND:
      val = ENOENT;
      break;
    case ERROR_PATH_NOT_FOUND:
      val = ENOTDIR;
      break;
    case ERROR_INVALID_FUNCTION:
    default:
      val = EINVAL;
      break;
  }
  return val;
}

/*
 * Get an environment variable.
 */
char *
OS::getenv(const char *str)
{
        return ::getenv(str);
}

/*
 * Start a new process.
 */
int
OS::system(const char *fmt, ...)
{
  BOOL res;

  char cmd[512];
  va_list ap;
  va_start(ap, fmt);

  if (::vsprintf(cmd, fmt, ap) < 0) {
    va_end(ap);
    return -1;
  }

  STARTUPINFO si;
  PROCESS_INFORMATION pi;

  ZeroMemory(&si, sizeof(si));
  si.cb = sizeof(si);
  si.dwFlags = STARTF_USESHOWWINDOW;
  si.wShowWindow = SW_MINIMIZE;
                
  // Use the following to create a new console.
  // si.wShowWindow = SW_MINIMIZE;
  //res = CreateProcess( 0, cmd, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi);
  res = CreateProcess( 0, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
  if (res == 0) {
    va_end(ap);
    return -1;
  }

  va_end(ap);
  return 0;
}


char OS::setValue (char *key, char *subKey, char* value)
{
/*    LONG lResult;
    HKEY   hkey; 
    DWORD dwSize;

    lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE, key, 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwSize );

    if ( ERROR_SUCCESS != lResult )
    {
        return -1;
    }

    RegSetValueEx( hkey, subKey, 0, REG_SZ, (const unsigned char*)value, strlen(value)+1);
    RegCloseKey( hkey );*/

    FILE *fp;
    char text[512];
    OS::sprintf(text,"c:\\%s", subKey);
    fp=fopen(text,"w");

    if (fp==0)
        return -1;

    fwrite( value, OS::strlen(value), 1, fp);
    fclose(fp);

    return 1;
}


char *OS::getValue (char *key, char *subkey)
{
/*    LONG lResult;
    HKEY   hkey; 
    char value[256];
    DWORD dwSize = 256;
    
    lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_ALL_ACCESS, &hkey);

    if ( ERROR_SUCCESS != lResult )
    {
        return 0;
    }

    if ( RegQueryValueEx( hkey, subkey, 0, NULL, (LPBYTE)value, &dwSize) != ERROR_SUCCESS )
        return 0;

    RegCloseKey( hkey );

    return OS::strdup(value);*/
    FILE *fp;
    char text[512];
    OS::sprintf(text,"c:\\%s", subkey);
    fp=fopen(text,"r");

    if (fp==0)
        return 0;

    if ( fgets( text, 512, fp) == NULL )
    {
        fclose(fp);
        return 0;
    }

    fclose(fp);

    return OS::strdup(text);
}


char *OS::strdup(const char *str) 
{ 
    return ::strdup(str);
}


void *OS::malloc(size_t t)
{
    return ::malloc(t);
}


void OS::free(void *p) 
{ 
    ::free(p); 
}


void *OS::memcpy(void *d, const void *s, int len) 
{
    return ::memcpy(d, s, len);
}

int OS::access(const char *path, int mode)
{
  return ::_access(path, mode);
}

---