void ExtractMapsFromMpq(uint32 build)
{
    char mpq_filename[1024];
    char output_filename[1024];
    char mpq_map_name[1024];

    printf("Extracting maps...\n");

    uint32 map_count = ReadMapDBC();

    ReadAreaTableDBC();
    ReadLiquidTypeTableDBC();

    std::string path = output_path;
    path += "/maps/";
    CreateDir(path);

    printf("Convert map files\n");
    for (uint32 z = 0; z < map_count; ++z)
    {
        printf("Extract %s (%d/%u)                  \n", map_ids[z].name, z+1, map_count);
        // Loadup map grid data
        sprintf(mpq_map_name, "World\\Maps\\%s\\%s.wdt", map_ids[z].name, map_ids[z].name);
        WDT_file wdt;
        if (!wdt.loadFile(WorldMpq, mpq_map_name, false))
            continue;

        for (uint32 y = 0; y < WDT_MAP_SIZE; ++y)
        {
            for (uint32 x = 0; x < WDT_MAP_SIZE; ++x)
            {
                if (!(wdt.main->adt_list[y][x].flag & 0x1))
                    continue;

                sprintf(mpq_filename, "World\\Maps\\%s\\%s_%u_%u.adt", map_ids[z].name, map_ids[z].name, x, y);
                sprintf(output_filename, "%s/maps/%03u%02u%02u.map", output_path, map_ids[z].id, y, x);
                ConvertADT(mpq_filename, output_filename, y, x, build);
            }

            // draw progress bar
            printf("Processing........................%d%%\r", (100 * (y+1)) / WDT_MAP_SIZE);
        }
    }

    printf("\n");
    delete [] areas;
    delete [] map_ids;
}
int CreateDirInPathAndBackToCurrentDir(char* dirName, char* path, char* currentDir)
{
    if(-1 == ChangeDirectory(path)) return -1;
    if (0 != access(dirName, F_OK))
    {
        if (ENOENT == errno) { // if file does not exist
            if(-1 == CreateDir(dirName)) return -1;
        }
        if (ENOTDIR == errno) {
            fprintf(stderr, "Not a directory!\n");
            return -1;
        }
    }
    if(-1 == ChangeDirectory(currentDir)) return -1;
    return 0;
}
Example #3
0
bool TForm1::MakeBackup() {
	UnicodeString dir = ExtractFileDir(m_strFileName) + "\\backups";
	if (!DirectoryExists(dir) && !CreateDir(dir)) {
		return false;
	}
	UnicodeString newfilename = ExtractFileName(m_strFileName);
	newfilename.Delete(newfilename.Length() - ExtractFileExt(m_strFileName).Length() + 1, ExtractFileExt(m_strFileName).Length());

	newfilename =
		dir + L"\\" +
		newfilename + " (" + TDateTime::CurrentDateTime().FormatString("yyyy-mm-dd hh_nn") + ")" +
		ExtractFileExt(m_strFileName);
	Log->Lines->Add("Сохраняю резервную копию файла в " + newfilename);
	bool bResult = CopyFile(m_strFileName.c_str(),newfilename.c_str(),false);
	return bResult;
}
static void CreateDir(const char *pPath)
{
	if(!pPath || *pPath == 0)
		return;

	// strip trailing '/'
	((char*)pPath)[MFString_Length(pPath)-1] = 0;

	// the path is empty
	if(*pPath == 0)
		return;

	CreateDir(MFStr_GetFilePath(pPath));

	CreateDirectory(pPath, NULL);
}
void RequestTests::Test_PdbImport()
{
	bool bExec = false;
    CMtClient client("127.0.0.1", 50);
    std::string sErrorMsg;
	int nServerRetCode = -1;
	std::string sServerResponse;
	std::ostringstream stCommand;
	std::wstring sPdbName;
	std::wstring sSymDir;
	std::wstring sOutFile;
	int nCreateDir = -1;

	sPdbName = Utils::GetTestDataFolder();
	sPdbName += L"CrashRpt.pdb";

	// Create symbol store dir
	sSymDir = Utils::GetTestDataFolder();
	sSymDir += L"sym";
	RmDir(sSymDir, false);
	nCreateDir = CreateDir(sSymDir);
	TEST_ASSERT_MSG(nCreateDir==0, "Error creating directory '%s'", strconv::w2a(sSymDir).c_str());

	sOutFile = sSymDir;
#ifdef _WIN32
	sOutFile += L"\\CrashRpt.pdb.txt";
#else
    sOutFile += L"/CrashRpt.pdb.txt";
#endif

	// Format command
	stCommand << "dumper --import-pdb \"" <<
		strconv::w2utf8(sPdbName) << "\" \"" <<
		strconv::w2utf8(sSymDir) << "\" \"" <<
		strconv::w2utf8(sOutFile) << "\"\n";

	// Execute daemon status command - assume success
    bExec = client.ExecuteRequest(stCommand.str().c_str(), nServerRetCode, sServerResponse, sErrorMsg);
	TEST_ASSERT_MSG(bExec, sErrorMsg.c_str());
	TEST_ASSERT_MSG(nServerRetCode==0, "Invalid ret code %d, msg = %s", nServerRetCode, sServerResponse.c_str());

	__TEST_CLEANUP__;

	// Delete sym directory
    RmDir(sSymDir, false);

}
Example #6
0
void ConfigManager::InitPaths()
{
#ifdef __WINDOWS__
    ConfigManager::config_folder = GetPortableConfigDir();
#else
    ConfigManager::config_folder = wxStandardPathsBase::Get().GetUserDataDir();
#endif
    ConfigManager::home_folder = wxStandardPathsBase::Get().GetUserConfigDir();
    ConfigManager::app_path = ::DetermineExecutablePath();
    wxString res_path = ::DetermineResourcesPath();

    // if non-empty, the app has overriden it (e.g. "--prefix" was passed in the command line)
    if (data_path_global.IsEmpty())
    {
        if(platform::windows)
            ConfigManager::data_path_global = app_path + _T("/share/codeblocks");
        else if(platform::macosx)
            ConfigManager::data_path_global = res_path + _T("/share/codeblocks");
        else
            ConfigManager::data_path_global = wxStandardPathsBase::Get().GetDataDir();
    }
#ifdef CB_AUTOCONF
    if (plugin_path_global.IsEmpty())
    {
        if(platform::windows || platform::macosx)
            ConfigManager::plugin_path_global = data_path_global;
        else
        {
            ConfigManager::plugin_path_global = wxStandardPathsBase::Get().GetPluginsDir() + _T("/plugins");
            // first assume, we use standard-paths
            if(!wxDirExists(ConfigManager::plugin_path_global) && wxIsPlatform64Bit())
            {
                // if standard-path does not exist and we are on 64-bit system, use lib64 instead
                ConfigManager::plugin_path_global = ((const wxStandardPaths&)wxStandardPaths::Get()).GetInstallPrefix() + _T("/lib64/codeblocks/plugins");
            }
        }
    }
#endif

    ConfigManager::data_path_user = ConfigManager::relo ? data_path_global : config_folder + _T("/share/codeblocks");

    CreateDirRecursively(ConfigManager::config_folder);
    CreateDirRecursively(ConfigManager::data_path_user   + _T("/plugins/"));
    CreateDir(ConfigManager::data_path_user   + _T("/scripts/"));

    ConfigManager::temp_folder = wxStandardPathsBase::Get().GetTempDir();
};
Example #7
0
QString CNeoCore::GetTempDir(bool bCreate)
{
	QString Path = Cfg()->GetString("Content/Temp");
	if(Path.isEmpty())
	{
		if(Cfg()->IsPortable())
			Path = Cfg()->GetAppDir();
		else
			QDir::homePath() + "/Downloads/NeoLoader";
		Path += "/Temp/";
	}
	if(Path.right(1) != "/")
		Path.append("/");
	if(bCreate)
		CreateDir(Path);
	return Path;
}
Example #8
0
bool CreateAllDirs(std::string path)
{

	std::vector<std::string> tocreate;
	std::string basepath = path;
	while(!PathExists(basepath))
	{
		tocreate.push_back(basepath);
		basepath = RemoveLastPathComponent(basepath);
		if(basepath.empty())
			break;
	}
	for(int i=tocreate.size()-1;i>=0;i--)
		if(!CreateDir(tocreate[i]))
			return false;
	return true;
}
Example #9
0
bool    plFileUtils::EnsureFilePathExists( const wchar_t *filename )
{
    hsWStringTokenizer  izer( filename, L"\\/" );

    bool    lastWorked = false;
    wchar_t   token[ kFolderIterator_MaxPath ];


    while( izer.Next( token, arrsize( token ) ) && izer.HasMoreTokens() )
    {
        // Want the full path from the start of the string
        lastWorked = CreateDir( izer.fString );
        izer.RestoreLastTerminator();
    }

    return lastWorked;
}
Example #10
0
/******************************************************************
 * my_mkdir / my_rmdir
 *
 * Create/Delete directories. Return AROS host error codes for 
 * AmigaOS guest CreateDir/DeleteFile calls.
 ******************************************************************/
int my_mkdir (const TCHAR *name) {

  BPTR lock;

  DebOut("name: %s\n", name);

  lock=CreateDir(name);

  if(lock) {
    UnLock(lock); /* CreateDir returns a lock, which we don't need */
    return 0;
  }

  SetLastError(IoErr());
  DebOut("return -1 (%d)\n", IoErr());
  return -1;
}
int MFFileNative_Open(MFFile *pFile, MFOpenData *pOpenData)
{
	MFCALLSTACK;

	MFDebug_Assert(pOpenData->cbSize == sizeof(MFOpenDataNative), "Incorrect size for MFOpenDataNative structure. Invalid pOpenData.");
	MFOpenDataNative *pNative = (MFOpenDataNative*)pOpenData;

	DWORD access = ((pOpenData->openFlags&MFOF_Read) ? GENERIC_READ : NULL) | ((pOpenData->openFlags&MFOF_Write) ? GENERIC_WRITE : NULL);
	MFDebug_Assert(access, "Neither MFOF_Read nor MFOF_Write specified.");

	const char *pFilename = pNative->pFilename;
#if defined(MF_XBOX) || defined(MF_X360)
	pFilename = FixXBoxFilename(pFilename);
#endif

	if(pOpenData->openFlags & MFOF_CreateDirectory)
		CreateDir(MFStr_GetFilePath(pFilename));

	DWORD create = (pOpenData->openFlags & MFOF_Read) ? ((pOpenData->openFlags & MFOF_Write) ? OPEN_ALWAYS : OPEN_EXISTING) : CREATE_ALWAYS;

	pFile->pFilesysData = CreateFile(pFilename, access, FILE_SHARE_READ, NULL, create, NULL, NULL);

	if(pFile->pFilesysData == INVALID_HANDLE_VALUE)
	{
//		MFDebug_Warn(3, MFStr("Failed to open file '%s'.", pNative->pFilename));
		pFile->pFilesysData = 0;
		return -1;
	}

	pFile->createFlags = pOpenData->openFlags;
	pFile->offset = 0;

	DWORD excess;
	uint32 fileSize = GetFileSize(pFile->pFilesysData, &excess);

	MFDebug_Assert(excess == 0, "Fuji does not support files larger than 4,294,967,295 bytes.");

	pFile->length = fileSize;

#if defined(_DEBUG)
	MFString_Copy(pFile->fileIdentifier, pNative->pFilename);
#endif

	return 0;
}
Example #12
0
bool CreateAllDirs(std::string path)
{

	size_t pos;
	std::vector<std::string> tocreate;
	std::string basepath = path;
	while(!PathExists(basepath))
	{
		tocreate.push_back(basepath);
		pos = basepath.rfind('/');
		if(pos == std::string::npos)
			return false;
		basepath = basepath.substr(0,pos);
	}
	for(int i=tocreate.size()-1;i>=0;i--)
		CreateDir(tocreate[i]);
	return true;
}
Example #13
0
static void
SalvageDir(char *iname, char *oname)
{
    dirhandle in, out;
    afs_int32 myFid[3], parentFid[3];

    OpenDir(iname, &in);
    if (afs_dir_Lookup(&in, ".", myFid) || 
	afs_dir_Lookup(&in, "..", parentFid)) {
	printf("Lookup of \".\" and/or \"..\" failed: ");
	printf("%d %d %d %d\n", myFid[1], myFid[2], parentFid[1],
	       parentFid[2]);
	printf("Directory cannnot be salvaged\n");
    }
    CreateDir(oname, &out);
    DirSalvage(&in, &out, myFid[1], myFid[2], parentFid[1], parentFid[2]);
    DFlush();
}
Example #14
0
bool DataMgr::SaveToFile(const char *fileName)
{
	const char * _file = NULL;
	if (fileName)
	{
		_file = fileName;
		m_save_file = fileName;
	}
	else
		_file = m_save_file.c_str();

	FILE*file = fopen(_file,"wb");
	if (!file){
		CreateDir(_file);
		file = fopen(_file, "wb");
		if (!file){
			CCLog("SaveStr(%s) Failed", _file);
			return false;
		}
	}

	StringMap::iterator it = m_StringMap.begin(),itEnd = m_StringMap.end();

	std::string temp;
	for(;it != itEnd;++it)
	{
		size_t len = it->first.size();
		size_t size = strlen(SAVE_TAG);
		size_t pos = it->first.find(SAVE_TAG);
		if (len >= size && pos == len-size)
		{
			temp = it->first;
			temp += "=";
			temp += it->second;
			temp += "\n";
			std::string decryptedstr = GetDecryptedStr(temp.c_str(),temp.size());
			fwrite(decryptedstr.c_str(),1,(int)decryptedstr.size(),file);
		}
	}

	fclose(file);

	return true;
}
Example #15
0
void ExtractCameraFiles()
{
    printf("Extracting camera files...\n");
    DBCFile camdbc("DBFilesClient\\CinematicCamera.dbc");

    if (!camdbc.open())
    {
        printf("Unable to open CinematicCamera.dbc. Camera extract aborted.\n");
        return;
    }

    // get camera file list from DBC
    std::vector<std::string> camerafiles;
    size_t cam_count = camdbc.getRecordCount();

    for (uint32 i = 0; i < cam_count; ++i)
    {
        std::string camFile(camdbc.getRecord(i).getString(1));
        size_t loc = camFile.find(".mdx");
        if (loc != std::string::npos)
            camFile.replace(loc, 4, ".m2");
        camerafiles.push_back(std::string(camFile));
    }

    std::string path = output_path;
    path += "/Cameras/";
    CreateDir(path);

    // extract M2s
    uint32 count = 0;
    for (std::string thisFile : camerafiles)
    {
        std::string filename = path;
        filename += (thisFile.c_str() + strlen("Cameras\\"));

        if (FileExists(filename.c_str()))
            continue;

        if (ExtractFile(thisFile.c_str(), filename))
            ++count;
    }
    printf("Extracted %u camera files\n", count);
}
Example #16
0
bool CreateDirRec(const char *dir)
{
    if(IsDirectory(dir))
        return true;
    bool result = true;
    StringList li;
    StrSplit(dir, "/\\", li, false);
    std::string d;
    d.reserve(strlen(dir));
    bool last;
    for(StringList::iterator it = li.begin(); it != li.end(); ++it)
    {
        d += *it;
        last = CreateDir(d.c_str());
        result = last && result;
        d += '/';
    }
    return result || last;
}
Example #17
0
void Cross::CreatePlatformConfigDir(std::string& in) {
#ifdef WIN32
	W32_ConfDir(in,true);
	in += "\\DOSBox";
	mkdir(in.c_str());
#elif defined(MACOSX)
	in = "~/Library/Preferences/";
	ResolveHomedir(in);
	//Don't create it. Assume it exists
#elif defined(HW_RVL)
	in = std::string(appDrive) + "/DOSBox";
	CreateDir(in);
#else
	in = "~/.dosbox";
	ResolveHomedir(in);
	mkdir(in.c_str(),0700);
#endif
	in += CROSS_FILESPLIT;
}
Example #18
0
int ReadBuild(int locale)
{
    Log sLog;

    // include build info file also
    std::string filename  = std::string("component.wow-")+langs[locale]+".txt";
    //sLog.Write("Read %s file... ", filename.c_str());
    
    CreateDir("./dbc/");
    ExtractFileToHardDrive(localeMPQ[0], filename.c_str(), (std::string("./dbc/") + filename).c_str());
    
    std::string text;
    std::string temp;
    
    std::ifstream fichier((std::string("./dbc/") + filename).c_str(), std::ios::in);
    if(!fichier)
        assert(false && "Error when loading component.wow-...");
    while(fichier)
    {
        fichier >> temp;
        text += temp;
    }
    
    size_t pos = text.find("version=\"");
    size_t pos1 = pos + strlen("version=\"");
    size_t pos2 = text.find("\"",pos1);
    if (pos == text.npos || pos2 == text.npos || pos1 >= pos2)
    {
        sLog.Write("Fatal error: Invalid  %s file format!", filename.c_str());
        exit(1);
    }
    
    std::string build_str = text.substr(pos1,pos2-pos1);
    
    int build = atoi(build_str.c_str());
    if (build <= 0)
    {
        sLog.Write("Fatal error: Invalid  %s file format!", filename.c_str());
        exit(1);
    }
    
    return build;
}
Example #19
0
bool ForceDirectories(const UnicodeString & Dir)
{
  bool Result = true;
  if (Dir.IsEmpty())
  {
    return false;
  }
  UnicodeString Dir2 = ExcludeTrailingBackslash(Dir);
  if ((Dir2.Length() < 3) || DirectoryExists(Dir2))
  {
    return Result;
  }
  if (ExtractFilePath(Dir2).IsEmpty())
  {
    return ::CreateDir(Dir2);
  }
  Result = ForceDirectories(ExtractFilePath(Dir2)) && CreateDir(Dir2);
  return Result;
}
Example #20
0
/*
 * Creates peudo DEV:DFx files.
 */
void initpseudodevices(void)
{
    ULONG lock;
    int i;

    pseudo_dev_created  = 0;
    pseudo_dev_assigned = 0;
    for(i=0;i<4;++i) dfx_done[i]=0;

    /* check if dev: already exists */
    set_req(0);lock = Lock(amiga_dev_path,SHARED_LOCK);set_req(1);
    if(!lock) {
	char name[80];
	set_req(0);lock = Lock(pseudo_dev_path,SHARED_LOCK);set_req(1);
	if(!lock) {
	    /* create it */
	    lock = CreateDir(pseudo_dev_path);
	    if(!lock) goto fail;
	    UnLock(lock);lock = Lock(pseudo_dev_path,SHARED_LOCK);
	    pseudo_dev_created = 1;
	}
	strcpy(name,amiga_dev_path);
	if(*name && name[strlen(name)-1]==':') name[strlen(name)-1]='\0';
	if(!AssignLock(name,lock)) {UnLock(lock);goto fail;}
	/* the lock is the assign now */
	pseudo_dev_assigned = 1;
    } else UnLock(lock);

    /* Create the dev:DFi entry */
    for(i=0;i<4;++i) if(device_exists("trackdisk.device",i)) {
	ULONG fd;
	char name[80];

	sprintf(name,"%sDF%d",amiga_dev_path,i);
	fd = Open(name,MODE_NEWFILE);
	if(fd) {Close(fd);dfx_done[i]=1;}
    }

    return;
 fail:
    fprintf(stderr,"Failed to create pseudo dev: entry!\n");
}
Example #21
0
void TDebug::OpenNewFile()
{
  if (f)
    CloseCurFile();
  if (!DirectoryExists("log"))
    CreateDir("log");
	static int log_id = 1;
	while (log_id < 1000) {
		char file_name[32];
		sprintf(file_name,"log\\log.%03d", log_id);
		f = fopen(file_name, "r+");
		if (f) {
			fclose(f);
			log_id++;
			continue;
		}
		f = fopen(file_name,"a+");
		break;
	}
}
Example #22
0
std::string FileUpload::getLocalIconPath()
{
    std::string Ret = ns::NsPlatformHelper::getExternalRootPath();
    if (Ret.empty())
    {
        CCLOG("getLocalIconPath, getExternalRootPath() fail");
        return "";
    }
    
    Ret += "/";
    Ret += FileUpload::GetFileTypeDir(UploadFileType_Icon);
    if (!CreateDir(Ret))
    {
        CCLOG("getLocalIconPath, CreateDir fail - %s", Ret.c_str());
        return "";
    }
    
    Ret += "/";
    return Ret;
}
Example #23
0
void DepthOptimizer::RefineAllDepthMaps(){
	LoadDataEx();
	for (int k = 0; k < ParamParser::imgdirs.size(); ++k){
		char fn[128];
		CreateDir(ParamParser::imgdirs[k] + "DATA/Refine/");

		std::vector<double> dsp;
		int n = cameras[k].size();
		for (int i = 0; i < n; ++i){
			sprintf_s(fn, "%sDATA/Render/_depth%d.raw", ParamParser::imgdirs[k].c_str(), i);
			LoadDepth(fn, dsp, cameras[k][i].W(), cameras[k][i].H());
			
			RefineDepthMap(k, i, dsp);

			sprintf_s(fn, "%sDATA/Refine/_depth%d.jpg", ParamParser::imgdirs[k].c_str(), i);
			RenderDepthMap(fn, dsp, cameras[k][i].W(), cameras[k][i].H());
			sprintf_s(fn, "%sDATA/Refine/_depth%d.raw", ParamParser::imgdirs[k].c_str(), i);
			SaveDepth(fn, dsp);
		}
	}
}
Example #24
0
void ExtractMapsFromMpq()
{
    char mpq_filename[1024];
    char output_filename[1024];

    printf("Extracting maps...\n");

    uint32 map_count = ReadMapDBC();

    ReadAreaTableDBC();
    ReadLiquidTypeTableDBC();

    unsigned int total = map_count * ADT_RES * ADT_RES;
    unsigned int done = 0;

    std::string path = output_path;
    path += "/maps/";
    CreateDir(path);

    for(uint32 x = 0; x < ADT_RES; ++x)
    {
        for(uint32 y = 0; y < ADT_RES; ++y)
        {
            for(uint32 z = 0; z < map_count; ++z)
            {
                sprintf(mpq_filename, "World\\Maps\\%s\\%s_%u_%u.adt", map_ids[z].name, map_ids[z].name, x, y);
                sprintf(output_filename, "%s/maps/%03u%02u%02u.map", output_path, map_ids[z].id, y, x);
                ConvertADT(mpq_filename, output_filename);
                done++;
            }
            // draw progress bar
            printf("Processing........................%d%%\r", (100 * done) / total);
        }
    }

    delete [] areas;
    delete [] map_ids;
}
Example #25
0
bool plFileSystem::CreateDir(const plFileName &dir, bool checkParents)
{
    plFileName fdir = dir;
    if (fdir.GetFileName().IsEmpty()) {
        hsDebugMessage("WARNING: CreateDir called with useless trailing slash", 0);
        fdir = fdir.StripFileName();
    }

    if (checkParents) {
        plFileName parent = fdir.StripFileName();
        if (parent.IsValid() && !plFileInfo(parent).Exists() && !CreateDir(parent, true))
            return false;
    }

    if (plFileInfo(fdir).Exists())
        return true;

#if HS_BUILD_FOR_WIN32
    return CreateDirectoryW(fdir.AsString().ToWchar(), nullptr);
#else
    return (mkdir(fdir.AsString().c_str(), 0755) == 0);
#endif
}
Example #26
0
//若是不存在上级文件夹则自动创建
bool zs_ut_s::CreateRecursionDir(std::string path)
{
	if (path.length() == 0) return true;
	std::string sub;
	char lastchar=0;
	//预处理
	FixPath(path);
	std::string::size_type pos = path.find('/');
	while (pos != std::string::npos)
	{
		std::string cur = path.substr(0, pos-0);
		if (cur.length() > 0 && !IsDirectory(cur))
		{
			if (!CreateDir(cur))
			{
				return false;
			}
		}
		pos = path.find('/', pos+1);
	}
	
	return true;
}
Example #27
0
int FileExist(const char *comname,ST_OptLogCfgData *cfg)
{
    DIR *dir;
    struct dirent *dirent;
    if (!comname || !(*comname) || !cfg)
    {
        return -1;
    }
    if (access(cfg->rcdpath,F_OK))
    {
         if (CreateDir(cfg->rcdpath)<0)
         {
             Debug_print("create directory %s for Record file failed",cfg->rcdpath);
             return -1;
         }
    }
    dir = opendir(cfg->rcdpath);
    if (!dir)
    {
        perror("open directory failed");
        return -1;
    }
    while((dirent=readdir(dir))!=NULL)
    {
        if(strstr(dirent->d_name,comname))
        {
            Debug_print("get dirent name :%s\n",dirent->d_name);
            pthread_mutex_lock(&gendata.pathmutex);
            snprintf(gendata.path,PATHLEN,"%s/%s",cfg->rcdpath,dirent->d_name);
            pthread_mutex_unlock(&gendata.pathmutex);
            closedir(dir);
            return 1;
        }
    }
    closedir(dir);
    return 0; 
}
Example #28
0
bool CStaticsFile::CreateDir(std::string &path)
{
	struct stat buf;
	if(stat(path.c_str(), &buf) ==0)
	{
		if(S_ISDIR(buf.st_mode))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		char *str = strdup(path.c_str());
		std::string cdir=dirname(str);
		free(str);
		if(CreateDir(cdir))
		{
			if(mkdir(path.c_str(),0755)==0) 
			{
				return true;
			}
			else 
			{
				return false;
			}
		}		
		else
		{
			return false;
		}
	}
	return false;
}
Example #29
0
QByteArray QFileIOService::ExecuteRDSCommand(QRDSServer &rdsserver, quint8 command, const QMap<QString, QString> &map)
{
    QByteArray ret;

    switch (command)
    {
    case QBrowseDirCommand:
        return BrowseDir(rdsserver, map);
        break;
    case QFileReadCommand:
        return FileRead(rdsserver, map);
        break;
    case QFileWriteCommand:
        return FileWrite(rdsserver, map);
        break;
    case QFileRenameCommand:
        return FileRename(rdsserver, map);
        break;
    case QFileRemoveFileCommand:
        return FileRemove(rdsserver, map, true);
        break;
    case QFileRemoveDirectoryCommand:
        return FileRemove(rdsserver, map, false);
        break;
    case QFileExistCommand:
        return Existence(rdsserver, map);
        break;
    case QFileCreateDirCommand:
        return CreateDir(rdsserver, map);
        break;
    case QFileGetRootDirCommand:
        return GetRootDir(rdsserver);
        break;
    }

    return ret;
}
Example #30
0
// 保存日志
void CLog::Save(LPCTSTR folder)
{
	if (m_logDocument.p == NULL)
		return;

	// 取日志HTML
	CComDispatchDriver documentDisp(m_logDocument);

	// document.documentElement.outerHTML
	_variant_t res;
	if (FAILED(documentDisp.GetPropertyByName(OLESTR("documentElement"), res.GetAddress())))
		return;
	CComDispatchDriver documentElementDisp((IDispatch*)res);
	if (FAILED(documentElementDisp.GetPropertyByName(OLESTR("outerHTML"), res.GetAddress())))
		return;
	CString strHtml = (LPCTSTR)(_bstr_t)res;

	// 另一种取网页HTML方法,末尾有四个乱码?
	/*CComPtr<IPersistStreamInit> psi;
	document->QueryInterface(&psi);
	HGLOBAL html = GlobalAlloc(GMEM_MOVEABLE, 5 * 1024 * 1024);
	IStream *stream;
	CreateStreamOnHGlobal(html, TRUE, &stream);
	psi->Save(stream, FALSE);
	CString strHtml = (LPCTSTR)GlobalLock(html);
	strHtml += _T("</body></html>");
	GlobalUnlock(html);
	stream->Release();*/

	// 保存
	CreateDir(folder);
	CString path;
	path.Format(_T("%s\\%d-%02d-%02d %02d:%02d:%02d.html"), folder, m_logStartTime.wYear, m_logStartTime.wMonth,
		m_logStartTime.wDay, m_logStartTime.wHour, m_logStartTime.wMinute, m_logStartTime.wSecond);
	WriteString(strHtml, path);
}