Ejemplo n.º 1
0
    std::string getenv(const char *var) {
      size_t       bufSize;
      std::wstring wvar = boost::filesystem::path(var, qi::unicodeFacet()).wstring(qi::unicodeFacet());

     #ifdef _MSC_VER
      wchar_t     *envDir = NULL;
      _wdupenv_s(&envDir, &bufSize, wvar.c_str());
      if (envDir == NULL)
        return "";

      boost::filesystem::path dest(envDir, qi::unicodeFacet());
      std::string ret(dest.string(qi::unicodeFacet()).c_str());
      free(envDir);
      return ret;
    #else
      _wgetenv_s(&bufSize, NULL, 0,  wvar.c_str());

      wchar_t *envDir = (wchar_t *) malloc(bufSize * sizeof(wchar_t));
      _wgetenv_s(&bufSize, envDir, bufSize, wvar.c_str());

      if (envDir == NULL)
        return "";

      boost::filesystem::path dest(envDir, qi::unicodeFacet());
      std::string ret(dest.string(qi::unicodeFacet()).c_str());
      free(envDir);
      return ret;
     #endif
    }
Ejemplo n.º 2
0
	std::wstring getAppDataFolderPath()
	{
		std::wstring str = L"";
		wchar_t* buf;
		size_t size;
		_wdupenv_s(&buf, &size, L"APPDATA");
		str += buf;
		str += L"\\";// TODO
		str += s_appDataFolderBasename;
		return str;
	}
Ejemplo n.º 3
0
bool GetEnvVar(_In_z_ wchar_t *var, MyString &res)
{
    wchar_t *buffer;
    size_t size;
    _wdupenv_s(&buffer, &size, var);
    if (!size || !buffer)
        return false;
    res = buffer;
    free(buffer); // Don't forget to free the buffer!
    return true;
}
Ejemplo n.º 4
0
static PyObject *
winutil_getenv(PyObject *self, PyObject *args) {
    const Py_UNICODE *q;
    if (!PyArg_ParseTuple(args, "u", &q)) return NULL;
    wchar_t *buf = NULL;
    size_t sz = 0;
    PyObject *ans = NULL;
    if (_wdupenv_s(&buf, &sz, q) != 0 || buf == NULL || sz == 0) { ans = Py_None; Py_INCREF(ans); }
    else ans = PyUnicode_FromWideChar(buf, sz - 1);
    if (buf) free(buf);
    return ans;
}
Ejemplo n.º 5
0
Archivo: lib.c Proyecto: pfmoore/shimmy
wchar_t *find_on_path(wchar_t *name)
{
    wchar_t *pathext;
    size_t   varsize;
    wchar_t *context = NULL;
    wchar_t *extension;
    wchar_t *result = NULL;
    DWORD    len;
    errno_t  rc;
    /* Return value storage - we don't need to be re-entrant */
    static wchar_t path_buf[MAX_PATH];

    if (wcschr(name, L'.') != NULL) {
        /* assume it has an extension. */
        len = SearchPathW(NULL, name, NULL, MAX_PATH, path_buf, NULL);
        if (len) {
            result = path_buf;
        }
    }
    else {
        /* No extension - search using registered extensions. */
        rc = _wdupenv_s(&pathext, &varsize, L"PATHEXT");
        if (rc == 0) {
            extension = wcstok_s(pathext, L";", &context);
            while (extension) {
                len = SearchPathW(NULL, name, extension, MAX_PATH, path_buf, NULL);
                if (len) {
                    result = path_buf;
                    break;
                }
                extension = wcstok_s(NULL, L";", &context);
            }
            free(pathext);
        }
    }
    if (result) {
        /* We just want the directory */
        wchar_t *end = wcsrchr(result, L'\\');
        *end = L'\0';
    }
    return result;
}
Ejemplo n.º 6
0
void IntelFaceScanner::renderScan()
{
  // Setup the output path to a writable location.
    size_t unused;
    WCHAR* pUserProfilePath;
    _wdupenv_s(&pUserProfilePath, &unused, L"USERPROFILE");
    const PXC3DScan::FileFormat format = PXC3DScan::PLY; // OBJ, PLY or STL
    const pxcCHAR* ext = PXC3DScan::FileFormatToString(format);
    const size_t FSIZE = 4096;
    WCHAR filename[FSIZE];
    //swprintf_s(filename, FSIZE, L"%s\\Documents\\Pierre3dscan.%s", pUserProfilePath, ext);
    swprintf_s(filename, FSIZE, L".\\data\\3dscan.%s", ext);

    // If applicable, reconstruct the 3D Mesh to the specific file/format
	pxcStatus result = PXC_STATUS_NO_ERROR;
    bool bMeshSaved = false;
    if (scanner->IsScanning())
    {
        wprintf_s(L"Generating %s...", filename);
        result = scanner->Reconstruct(format, filename);
        if (result >= PXC_STATUS_NO_ERROR)
        {
            bMeshSaved = true;
            wprintf_s(L"done.\n");
        }
		else if (result == PXC_STATUS_FILE_WRITE_FAILED)
        {
            wprintf_s(L"the file could not be created using the provided path. Aborting.\n");
        }
        else if (result == PXC_STATUS_ITEM_UNAVAILABLE || result == PXC_STATUS_DATA_UNAVAILABLE)
        {
            wprintf_s(L"no scan data found. Aborting.\n");
        }
        else if (result < PXC_STATUS_NO_ERROR)
        {
            wprintf_s(L"\nError: Reconstruct returned %d\n", result);
        }
    }
    else wprintf_s(L"Empty scanning volume.\n");
}
Ejemplo n.º 7
0
wstring TargetPage::getEnvironmentVariable(const wchar_t *name)
{
  wchar_t
    *buffer;

  size_t
    length;

  wstring
    value;

  if (_wdupenv_s(&buffer,&length,name) == 0)
  {
    if (length > 0)
    {
      value=wstring(buffer);
      free(buffer);
      return(value);
    }
  }

  return(value);
}
Ejemplo n.º 8
0
	std::wstring getFullPathUnicode(FileLocalization fileLocalization, const char* filepath)
	{
		std::wstring str;
#if defined(USES_WINDOWS8_DESKTOP) || defined(USES_WINDOWS_OPENGL)
		if (fileLocalization == APPLICATION_FOLDER)
		{
			str += Utils::getCurrentDirectoryUnicode();
		}
		else if (fileLocalization == APPLICATION_DATA_FOLDER)
		{
			wchar_t* buf;
			size_t size;
			errno_t res = _wdupenv_s(&buf, &size, L"APPDATA");
			Assert(res == 0 && buf != NULL);
			str += buf;
			str += L"\\";// TODO
			str += s_appDataFolderBasename;
			struct _stat st;
			if (_wstat(str.c_str(), &st) != 0) // if file does not exist
			{
				_wmkdir(str.c_str());
			}
			free(buf);
		}
		else
		{
			Assert(false);// TODO
		}
#elif defined(USES_WINDOWS8_METRO)
		str = getStorageFolder(fileLocalization)->Path->Data();
#elif defined(USES_LINUX)
	#error todo
#endif
		str += L"\\";
		str += Utils::convertStringToWString(filepath);
		return str;
	}
Ejemplo n.º 9
0
mmString mmOperatingSystem::GetUniqueIDString(void)
{
	mmString v_sOutIDString;

  // Hard Drive ID
	DWORD v_sSN,v_sDW1,v_sDW2;
	wchar_t v_cS1[256];
	wchar_t v_cS2[256];

	wchar_t * v_pcWinDir = NULL;
	std::size_t v_iWinDirSize = 0;
	_wdupenv_s(&v_pcWinDir, &v_iWinDirSize, L"windir");

	mmString v_sDrive = mmString(v_pcWinDir).substr(0,3);
	GetVolumeInformation(v_sDrive.c_str(), v_cS1, 256, &v_sSN, &v_sDW1, &v_sDW2, v_cS2, 256);

	free(v_pcWinDir);

	wchar_t v_cHDD[256];
	swprintf_s(v_cHDD,L"%d",v_sSN);
	mmString v_sHDD = v_cHDD;

	// Program tick count
	std::clock_t v_sCurrentClock = v_sCurrentClock = clock();

	wchar_t v_cCLK[256];
	swprintf_s(v_cCLK,L"%d",v_sCurrentClock);
	mmString v_sCLK = v_cCLK;

	// date time
	mmString v_sDateTime = mmStringUtilities::GetCurrentDateTimeString();

	v_sOutIDString = v_sHDD + v_sCLK + mmString(L"_") + v_sDateTime;

	return v_sOutIDString;
}
Ejemplo n.º 10
0
int _tmain(int argc, _TCHAR* argv[])
{
    TCHAR szPath[MAX_PATH] = { 0, };
    DWORD dwSize = GetModuleFileName(NULL, szPath, MAX_PATH);
    TCHAR * pdest = _tcsrchr(szPath, '\\');
    _tcsncpy_s(gServicePath, sizeof(gServicePath) / sizeof(TCHAR), szPath, (size_t)(pdest - szPath));

    if (argc < 2)
    {
        ExecuteSubProcess();
        return 0;
    }
    
    if (_tcsicmp(L"/i", argv[1]) == 0)
        return Install(szPath, ServiceName);
    else if (_tcsicmp(L"/k", argv[1]) == 0)
        return KillService(ServiceName);
    else if (_tcsicmp(L"/u", argv[1]) == 0)
        return UnInstall(ServiceName);
    else if (_tcsicmp(L"/s", argv[1]) == 0)
        return RunService(ServiceName);
    else if (_tcsicmp(L"/t", argv[1]) == 0)
    {
        DWORD dwPID;
        WCHAR *szServicePath;
        WCHAR *cmd = L"drbdadm.exe initial-split-brain minor-6";
        WCHAR fullName[MAX_PATH] = {0};

        size_t len;
        errno_t err = _wdupenv_s(&szServicePath, &len, L"DRBD_PATH");
        if (err)
        {
            // default
            szServicePath = L"C:\\Program Files\\drbd\\bin";
        }
        if ((wcslen(szServicePath) + wcslen(cmd) + 4) > MAX_PATH)
        {
            printf("szServicePath: too big!!\n");
        }
        wcsncpy_s(fullName, szServicePath, wcslen(szServicePath));
        wcscat_s(fullName, L"\\");
        wcsncat_s(fullName, cmd, wcslen(cmd)); //wnsprintf
        printf("fullName: %ws\n", fullName);

        // test!
        DWORD ret = RunProcess(EXEC_MODE_WIN, SW_NORMAL, NULL, cmd, szServicePath, dwPID, 0, NULL, NULL);
        free(szServicePath);
        return ERROR_SUCCESS;
    }
#if 1 // _WIN32_HANDLER_TIMEOUT: test by a separate application, not daemon. remove later
	else if (_tcsicmp(L"/n", argv[1]) == 0) 
	{
		// internal test only: no-daemon test

		unsigned short servPort = DRBD_DAEMON_TCP_PORT;
		DWORD threadID;

		if (CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SockListener, &servPort, 0, (LPDWORD) &threadID) == NULL)
		{
			WriteLog(L"pthread_create() failed\n");
			return 0;
		}

		int i = 0;
		while (1)
		{
			printf("test main loop(%d)...\n", i++);
			Sleep(10000);
		}
	}
#endif
    else
    {
        TCHAR msg[256];
        _stprintf_s(msg, _T("Usage: drbdService.exe [/i|/k|/u|/s]\n"));
        WriteLog(msg);
        return ERROR_INVALID_PARAMETER;
    }

    return ERROR_SUCCESS;
}