#ifdef _DEBUG -> #ifndef NDEBUG for better cmake compatibility

gcontini

2020-10-13 cbb11cd88d985db033c744b59291a2cf03fd16be

 src/library/os/windows/execution_environment.cpp

@@ -4,67 +4,63 @@
 *  Created on: Dec 15, 2019
 *      Author: GC
 */
#include <paths.h>
#include <windows.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/utsname.h>
#include <string>

#include "isvm/BIOSReader.h"
#include "isvm/Native.h"
#include "../../base/base.h"

#include "../cpu_info.hpp"
#include "../execution_environment.hpp"

namespace license {
namespace os {
using namespace std;

ExecutionEnvironment::ExecutionEnvironment() : m_container_type(CONTAINER_TYPE::NONE) {}

#define MAX_UNITS 20
CONTAINER_TYPE wine_container() {
   size_t ndrives = 0;
   const DWORD dwSize = MAX_PATH;
   char szLogicalDrives[MAX_PATH] = {0};

VIRTUALIZATION ExecutionEnvironment::getVirtualization() {
   VIRTUALIZATION result;
   CpuInfo cpuInfo;
   bool isContainer = false;
   if (isContainer) {
      result = CONTAINER;
   } else if (cpuInfo.cpu_virtual() || is_cloud()) {
      result = VM;
   } else {
      result = NONE;
   CONTAINER_TYPE result = CONTAINER_TYPE::NONE;
   const DWORD dwResult = GetLogicalDriveStrings(dwSize, szLogicalDrives);
	
   //FIXME! this code missed the increment in the loop... 
   if (dwResult > 0 && dwResult <= MAX_PATH) {
      char* szSingleDrive = szLogicalDrives;
      while (*szSingleDrive && ndrives < MAX_UNITS) {
         // get the next drive
         UINT driveType = GetDriveType(szSingleDrive);
         if (driveType == DRIVE_FIXED) {
            string name = szSingleDrive + string("/var/run/systemd/container");
            try {
               ifstream systemd_container(name);
               if (systemd_container.good()) {
                  result = CONTAINER_TYPE::DOCKER;
                  for (string line; getline(systemd_container, line);) {
                     if (line.find("docker") != string::npos) {
                        result = CONTAINER_TYPE::DOCKER;
                        break;
                     } else if (line.find("lxc") != string::npos) {
                        result = CONTAINER_TYPE::LXC;
                        break;
                     }
                  }
               }
            } catch (...) {
               // no problem,we're just guessing
            }
         }
      }
   }
   return result;
}

bool ExecutionEnvironment::is_cloud() { return getCloudProvider() != ON_PREMISE; }

bool ExecutionEnvironment::is_docker() { return false; }

CLOUD_PROVIDER ExecutionEnvironment::getCloudProvider() {
   if (InitEntryPoints()) {
      BIOSReader reader;
      SystemInformation info = reader.readSystemInfo();

      const char *vmVendors[] = {
         "VMware", "Microsoft Corporation", "Virtual Machine", "innotek GmbH", "PowerVM", "Bochs", "KVM"};

      const int count = _countof(vmVendors);
      for (int i = 0; i != count; ++i) {
         const char *vendor = vmVendors[i];

         if (std::string::npos != info.Manufacturer.find(vendor) ||
            std::string::npos != info.ProductName.find(vendor) ||
            std::string::npos != info.SerialNum.find(vendor)) {
            std::cout << "Inside virual machine!";
            return 1;
         }
      }
   } else {
      return -1;
   }
}

}  // namespace os
}  // namespace license