void Key::writeString( const std::string& sValueName, const std::string& sData ) { HKEY hKey; LONG lRtn = RegCreateKeyExW( m_hRootKey, m_wsPath.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegCreateKeyExW(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } std::wstring wData = utf8ToWide( sData ); std::wstring wValueName = utf8ToWide( sValueName ); lRtn = RegSetValueExW( hKey, wValueName.c_str(), 0, REG_SZ, reinterpret_cast<const BYTE*>(wData.c_str()), static_cast<DWORD>(wData.length() * sizeof(wchar_t)) ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegSetValueExW(" + wideToUtf8(m_wsPath) + ", " + sValueName + ", " + sData + ") returned: " + bp::conv::toString( lRtn ) ); } lRtn = RegCloseKey( hKey ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegCloseKey(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } }
static void replaceItemNameParams(T* itm, pugi::xml_node& xmlNode) { const char* name = xmlNode.attribute("name").value(); const char* desc = xmlNode.attribute("desc").value(); const char* fname = xmlNode.attribute("fname").value(); // replace description if(strcmp(desc, itm->m_Description) != 0) { free(itm->m_Description); free(itm->m_DescriptionW); itm->m_Description = strdup(desc); itm->m_DescriptionW = wcsdup(utf8ToWide(itm->m_Description)); } // replace name if(strcmp(name, itm->m_StoreName) != 0) { free(itm->m_StoreName); free(itm->m_StoreNameW); itm->m_StoreName = strdup(name); itm->m_StoreNameW = wcsdup(utf8ToWide(itm->m_StoreName)); } // replace store icon (FNAME) char storeIcon[256]; sprintf(storeIcon, "$Data/Weapons/StoreIcons/%s.dds", fname); if(strcmp(storeIcon, itm->m_StoreIcon) != 0) { free(itm->m_StoreIcon); itm->m_StoreIcon = strdup(storeIcon); } }
void Key::writeInt( const std::string& sValueName, int nData ) { HKEY hKey; LONG lRtn = RegCreateKeyExW( m_hRootKey, m_wsPath.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegCreateKeyExW(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } std::wstring wValueName = utf8ToWide( sValueName ); lRtn = RegSetValueExW( hKey, wValueName.c_str(), 0, REG_DWORD, reinterpret_cast<BYTE*>(&nData), sizeof(nData) ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegSetValueExW(" + wideToUtf8(m_wsPath) + ", " + sValueName + ", " + bp::conv::toString( nData ) + ") returned: " + bp::conv::toString( lRtn ) ); } lRtn = RegCloseKey( hKey ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegCloseKey(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } }
std::string Key::readString( const std::string& sValueName ) const { HKEY hKey; LONG lRtn = RegOpenKeyExW( m_hRootKey, m_wsPath.c_str(), 0, KEY_READ, &hKey ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegOpenKeyExW(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } // TODO: could use RegQueryInfo to get required buf size. const int knBufSize = 2000; BYTE szBuf[knBufSize]; DWORD dwBufSize = knBufSize; std::wstring wValueName = utf8ToWide( sValueName ); lRtn = RegQueryValueExW( hKey, wValueName.c_str(), NULL, NULL, szBuf, &dwBufSize ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegQueryValueExW(" + wideToUtf8(m_wsPath) + ", " + sValueName + ") returned: " + bp::conv::toString( lRtn ) ); } lRtn = RegCloseKey( hKey ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegCloseKey(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } std::wstring wval(reinterpret_cast<wchar_t*>( szBuf ) ); std::string rval = wideToUtf8( wval ); return rval; }
Value::Value( const std::string& sName, const Key* pParentKey, DWORD dwValueType ) : m_pParentKey( pParentKey ), m_dwValueType( dwValueType ) { m_wsName = utf8ToWide( sName ); }
Key::Key( const std::string& sPath ) : m_wsPath(), m_hRootKey() { // The first part of input path should be root key name. size_t nPos = sPath.find( "\\" ); string sRootKey = sPath.substr( 0, nPos ); m_hRootKey = rootKeyFromString( sRootKey ); // We'll store our path as everything after the root key and separator. m_wsPath= utf8ToWide( sPath.substr( nPos+1 ) ); }
bool MSWeaponArmory::loadItem(pugi::xml_node& xmlItem) { r3d_assert(!xmlItem.empty()); uint32_t itemID = xmlItem.attribute("itemID").as_uint(); for(uint32_t i=0; i<m_NumItemLoaded; ++i) // todo: change to hash table { if(m_ItemArray[i]->m_itemID == itemID) { r3dOutToLog("Trying to load an item with id '%d' that is already loaded!", itemID); return false; } } if(m_NumItemLoaded > MAX_NUMBER_ITEM-1) { r3dOutToLog("Trying to load more than maximum number of items. Maximum is '%d'\n", MAX_NUMBER_ITEM); return false; } ItemConfig* item = new ItemConfig(itemID); item->category = (STORE_CATEGORIES)xmlItem.attribute("category").as_int(); const char* desc = xmlItem.child("Store").attribute("desc").value(); r3d_assert(desc); item->m_Description = strdup(desc); item->m_StoreIcon = strdup(xmlItem.child("Store").attribute("icon").value()); item->m_StoreName = strdup(xmlItem.child("Store").attribute("name").value()); item->m_LevelRequired = xmlItem.child("Store").attribute("LevelRequired").as_int(); item->m_StoreNameW = wcsdup(utf8ToWide(item->m_StoreName)); item->m_DescriptionW = wcsdup(utf8ToWide(item->m_Description)); if(!xmlItem.child("Model").empty()) item->m_ModelPath = strdup(xmlItem.child("Model").attribute("file").value()); m_ItemArray[m_NumItemLoaded] = item; m_NumItemLoaded++; return true; }
int main(int argc, char **argv) { if (argc < 2) { printf("Usage: %s <drive letter>\n", argv[0]); return 0; } DOKAN_OPTIONS options; DOKAN_OPERATIONS operations; ZeroMemory(&options, sizeof(DOKAN_OPTIONS)); options.Version = DOKAN_VERSION; options.ThreadCount = 0; // use default std::wstring mountPoint = utf8ToWide(argv[1]); options.MountPoint = mountPoint.c_str(); options.Options = DOKAN_OPTION_DEBUG | DOKAN_OPTION_STDERR | DOKAN_OPTION_KEEP_ALIVE; ZeroMemory(&operations, sizeof(DOKAN_OPERATIONS)); operations.CreateFile = WendyCreateFile; operations.OpenDirectory = WendyOpenDirectory; operations.CreateDirectory = WendyCreateDirectory; operations.Cleanup = WendyCleanup; operations.CloseFile = WendyCloseFile; operations.ReadFile = WendyReadFile; operations.WriteFile = WendyWriteFile; operations.GetFileInformation = WendyGetFileInformation; operations.FindFiles = WendyFindFiles; operations.DeleteFile = WendyDeleteFile; operations.DeleteDirectory = WendyDeleteDirectory; operations.GetDiskFreeSpace = WendyGetDiskFreeSpace; operations.GetVolumeInformation = WendyGetVolumeInformation; fs = new FileSystem; InitializeCriticalSection(&wendyMutex); int result = DokanMain(&options, &operations); DeleteCriticalSection(&wendyMutex); delete fs; return result; }
static int DOKAN_CALLBACK WendyFindFiles(LPCWSTR filename, PFillFindData fillFindData, PDOKAN_FILE_INFO info) { ScopeLock lock; wprintf(L"FindFiles %s\n", filename); WIN32_FIND_DATAW entry; ZeroMemory(&entry, sizeof(WIN32_FIND_DATAW)); // insert special dirs '.' and '..' entry.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; wcscpy(entry.cFileName, L"."); fillFindData(&entry, info); wcscpy(entry.cFileName, L".."); fillFindData(&entry, info); std::string path = makePathStandard(filename); std::vector<std::string> files; fs->readdir(path, &files); for (unsigned int i = 0; i < files.size(); ++i) { // filename const std::string &filename = files[i]; std::wstring wfilename = utf8ToWide(filename); wcsncpy(entry.cFileName, wfilename.c_str(), MAX_PATH - 1); // other attributes FileSystem::FileAttributes attributes; std::string fullChildPath = files[i]; if (path.size() > 0) fullChildPath = path + "/" + files[i]; fs->stat(fullChildPath, &attributes); entry.dwFileAttributes = attributes.folder ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL; entry.nFileSizeLow = attributes.length; // TODO: use the 64 bits entry.ftLastWriteTime = unixTimeToFileTime(attributes.date); // send item back to caller fillFindData(&entry, info); } return 0; }
static int DOKAN_CALLBACK WendyCreateFile(LPCWSTR filename, DWORD accessMode, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes, PDOKAN_FILE_INFO info) { ScopeLock lock; wprintf(L"CreateFile: %s\n", filename); std::string path = makePathStandard(filename); FileSystem::FileAttributes attributes; bool exists = fs->stat(path, &attributes); // cases when the file MUST exist if (!exists && ((creationDisposition == OPEN_EXISTING) || (creationDisposition == TRUNCATE_EXISTING))) return -ERROR_PATH_NOT_FOUND; // cases when the file MUST NOT exist if (exists && (creationDisposition == CREATE_NEW)) return -ERROR_FILE_EXISTS; if (attributes.folder) { // flag as directory info->IsDirectory = TRUE; } else { // no real open if (accessMode == 0) return 0; // retrieve opening process name std::string processName = "unknown application"; HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, info->ProcessId); if (process != NULL) { wchar_t processBaseName[256]; DWORD length = GetModuleBaseName(process, NULL, processBaseName, 255); if (length > 0) processName = wideToUtf8(processBaseName); CloseHandle(process); } std::wstring processNameWide = utf8ToWide(processName); wprintf(L"%s opened by %s\n", filename, processNameWide.c_str()); // translate access mode bool reading = false; bool writing = false; //if ((accessMode & FILE_GENERIC_READ) == FILE_GENERIC_READ) reading = true; //if ((accessMode & FILE_GENERIC_WRITE) == FILE_GENERIC_WRITE) writing = true; reading = true; if (writing) return -ERROR_ACCESS_DENIED; // open asset File *file = fs->open(path, reading, writing, false, processName); if (!file) return -ERROR_PATH_NOT_FOUND; info->Context = (ULONG64)file; // file descriptor wprintf(L"CreateFile succeeded (handle = 0x%x\n", file); } return 0; }
char* realpath(const char * name, char * resolved) { char *retname = NULL; /* SUSv3 says we must set `errno = EINVAL', and return NULL, * if `name' is passed as a NULL pointer. */ if (name == NULL) { errno = EINVAL; return NULL; } /* Otherwise, `name' must refer to a readable filesystem object, * if we are going to resolve its absolute path name. */ wchar_t wideNameBuffer[PATH_MAX]; wchar_t *wideName = wideNameBuffer; if (!utf8ToWide(name, wideName, PATH_MAX)) { errno = EINVAL; return NULL; } if (_waccess(wideName, 4) != 0) return NULL; /* If `name' didn't point to an existing entity, * then we don't get to here; we simply fall past this block, * returning NULL, with `errno' appropriately set by `access'. * * When we _do_ get to here, then we can use `_fullpath' to * resolve the full path for `name' into `resolved', but first, * check that we have a suitable buffer, in which to return it. */ if ((retname = resolved) == NULL) { /* Caller didn't give us a buffer, so we'll exercise the * option granted by SUSv3, and allocate one. * * `_fullpath' would do this for us, but it uses `malloc', and * Microsoft's implementation doesn't set `errno' on failure. * If we don't do this explicitly ourselves, then we will not * know if `_fullpath' fails on `malloc' failure, or for some * other reason, and we want to set `errno = ENOMEM' for the * `malloc' failure case. */ retname = (char *)malloc(PATH_MAX); if (retname == NULL) { errno = ENOMEM; return NULL; } } /* Otherwise, when we do have a valid buffer, * `_fullpath' should only fail if the path name is too long. */ wchar_t wideFullPathBuffer[PATH_MAX]; wchar_t *wideFullPath; if ((wideFullPath = _wfullpath(wideFullPathBuffer, wideName, PATH_MAX)) == NULL) { errno = ENAMETOOLONG; return NULL; } // Do a LongPath<->ShortPath roundtrip so that case is resolved by OS // FIXME: Check for failure size_t initialLength = wcslen(wideFullPath); GetShortPathNameW(wideFullPath, wideNameBuffer, PATH_MAX); GetLongPathNameW(wideNameBuffer, wideFullPathBuffer, initialLength + 1); // Convert back to UTF-8 if (!wideToUtf8(wideFullPathBuffer, retname, PATH_MAX)) { errno = EINVAL; return NULL; } // Force drive to be upper case if (retname[1] == ':') retname[0] = toupper(retname[0]); return retname; }