Ejemplo n.º 1
0
bool CServerSession::OnLogOn( CNcpMessage* pMsg, int nBufSize )
{
    char path[MAXPATH];

    //parse parameters
    int nFileMode = pMsg->GetRet();
    string strUser = (char*)pMsg->GetData();
    string strPass = (char*)( pMsg->GetData()+strUser.size()+1 );

    //get home path
#ifdef _WIN32
    GetModuleFileName( NULL, path, ELEMENTS(path) );
    char* p = strrchr( path, '\\' );
    if( p!=NULL )*p = '\0';
#else
    getcwd( path, ELEMENTS(path) );
#endif
    CatDir( path, strUser.c_str(), path, ELEMENTS(path) );	//now path is the current home path.

    //make home directory if necessary
    int nRet = S_OK;
    if( !IsDirExist(path) ) {
        if( MkDir( path )!=0 ) {
            nRet = E_ACCES;
        }
    }
    m_strHomeDir = path;
    m_strCurDir = m_strHomeDir;
    m_nFileMode = nFileMode;

    if( SUCCEEDED(nRet) && !IsDirExist(m_strHomeDir.c_str()) ) {
        nRet = E_NOUSER;
    }
    pMsg->Init( CM_ACK, nRet );
    pMsg->Send( m_sock );

    //switch established
    if( SUCCEEDED(nRet) ) {
        m_state = NCPS_ESTABLISHED;
        if( strcmp( strUser.c_str(), "root" )==0 )m_bRootUsr = true;

        ASSERT( m_pServApp );
        //lock the same user logon from other hosts.
        m_pLocker = m_pServApp->GetSessionLocker( strUser.c_str() );
        m_pLocker->Lock();
    }
    return SUCCEEDED(nRet);
}
Ejemplo n.º 2
0
void Log::logToErrFile(const char* log)
{
	if(m_log_line==0 || m_err_log_file==NULL)
	{
		if(m_err_log_file)
			fclose(m_err_log_file);
		m_err_log_file=NULL;

		//日期变了,重设文件名
		char new_log_file_name[50] = {0};
		if(!IsDirExist("log"))
			MkDir("log");

		std::string log_time=StringReplace(StrTimeStamp(), ":", "_");
		sprintf_s(new_log_file_name, sizeof(new_log_file_name), "log\\error_%s.log", log_time.c_str());
		fopen_s(&m_err_log_file, new_log_file_name, "a");
		if(NULL==m_err_log_file)
			THROWNEXCEPT("create file:%s error.", new_log_file_name);
	}

	size_t count=strlen(log);
	size_t write_count=fwrite(log, sizeof(char), count, m_err_log_file);
	if(write_count!=count)
		THROWNEXCEPT("log to file error.");
}
Ejemplo n.º 3
0
bool MakeDir(const OJString &path)
{
    if (!IsDirExist(path))
    {
        fs::path            fullpath(path);
        sys::error_code     err;

        bool res = fs::create_directory(fullpath, err);

        if (!(sys::errc::success == err))
        {
            ILogger *logger = LoggerFactory::getLogger(LoggerId::AppInitLoggerId);
            OJString msg(GetOJString("[filetool] - IMUST::MakeDir - make dir failed: "));
            msg += path;
            msg += GetOJString(" - ");
            msg += String2OJString(err.message());
            logger->logError(msg);
            return false;
        } 

        return res;
    }

    return true;
}
Ejemplo n.º 4
0
bool MkDir(const char *pszName, mode_t mode)
{
    if(IsDirExist(pszName))
    {
        return 0;
    }

    if(IsFileExist(pszName))
    {
        return -2;                     
    }


    const char *p = pszName;
    if(*p == '/')
    {
        p++;
    }

    std::string strDir;

    while(*p != 0)
    {
        while((*p != '/') && (*p != 0))
        {
            p++;
        }
        
        strDir.assign(pszName, p - pszName);
        if(false == IsDirExist(strDir.c_str()))
        {
            if(-1 == mkdir(strDir.c_str(),mode))
            {
                return -1;
            }
        }
        
        if(*p == 0)
        {
            break;
        }
        p++;
    }
    return 0;
}
Ejemplo n.º 5
0
bool PathUtil::EnsureDir(const String &dir)
{
	if(!IsDir(dir))
		return false;
	
	if(!IsDirExist(dir))
	{
		if(!CreateDir(dir))
			return false;
	}
	
	return true;
}
Ejemplo n.º 6
0
int main(int argc,char *argv[])
{
    if( 2 != argc )
    {
        printf("%s param\n",argv[0]);
        return -1;
    }

    char *path = argv[1];
    if(0 == IsDirExist(path)){
        printf("path %s is dir\n", path);
    }
    else{
        printf("path %s is not dir\n", path);
    }

    return 0;
}
Ejemplo n.º 7
0
bool PathUtil::CreateDir(const String &dir)
{
	std::vector<std::string> paths;
	char seps[] = _T("/\\");
	char pathBuf[MAX_PATHNAME];
	char *token = NULL;
	
	memset(pathBuf, 0, MAX_PATHNAME);
	memcpy(pathBuf, dir.c_str(), dir.length() * sizeof(tchar));
	
	token = strtok(pathBuf, seps);
	
	std::string tempDir;
	while( token != NULL )
	{
		tempDir = token;
		if(!IsDriveOrRoot(tempDir))
		{
			paths.push_back(tempDir);
		}
		
		token = strtok(NULL, seps);
	}

	tempDir = StringUtil::ConvMBS(GetDriveOrRoot(dir));
	
	for(size_t i=0; i < paths.size(); ++i)
	{
		tempDir += paths[i];
		tempDir += SEPERATOR;
		
		if(!IsDirExist(tempDir))
		{
#if (LORD_PLATFORM == LORD_PLATFORM_WINDOWS)
			if(mkdir(tempDir.c_str()) != 0)
#else
			if(mkdir(tempDir.c_str(), S_IRWXU|S_IRWXG|S_IRWXO) != 0)
#endif
				return false;
		}
	}
	
	return true;
}
Ejemplo n.º 8
0
bool CServerSession::OnChDir( CNcpMessage* pMsg, int nBufSize )
{
    char path[MAXPATH];
    char* pNewDir = (char*)pMsg->GetData();

    int nRetCode = S_OK;

    if( strcmp(pNewDir, "~")==0 ) {
        m_strCurDir = m_strHomeDir;
    } else {
        //make the full path
        if( !IsAbsDir(pNewDir) ) {
            //this is a relative directory
            CatDir( m_strCurDir.c_str(), pNewDir, path, ELEMENTS(path) );
        } else {
            //this is a absolute directory
            strcpy( path, pNewDir );
        }

        if( IsDirExist(path) ) {
            NormDir( path, path, ELEMENTS(path) );
            //the path must be in the home directory
            if( IsSubDir(path, m_strHomeDir.c_str()) ) {
                m_strCurDir = path;
            } else {
                nRetCode = E_ACCES;
            }
        } else {
            nRetCode = E_NOENT;
        }
    }

    pMsg->Init( CM_ACK, nRetCode );
    pMsg->Send( m_sock );

    return SUCCEEDED( nRetCode );
}
Ejemplo n.º 9
0
int erase_dir( const char* path, bool rm_cur )
{
#ifdef _WIN32
	char buf[_MAX_PATH];
	dir_cat( path, "*.*", buf, ELEMENTS(buf) );
	struct _finddata_t fileinfo;
	intptr_t hfind = _findfirst( buf, &fileinfo );
	if( hfind==-1 ){
		errno = ENOENT;
		return -1;
	}

	do{
		char path_file[_MAX_PATH];
		dir_cat( path, fileinfo.name, path_file, ELEMENTS(path_file) );
		if( fileinfo.attrib & FILE_ATTRIBUTE_DIRECTORY ){
			if( strcmp(fileinfo.name,".")!=0 && strcmp(fileinfo.name, "..")!=0 ){
				if( erase_dir( path_file, true )!=0 ){	//clear the children path
					_findclose( hfind );
					return -1;
				}
			}
		}else{
			if( remove(path_file)!=0 ){
				_findclose( hfind );
				return -1;
			}
		}
	}while( _findnext( hfind, &fileinfo )==0 );
	_findclose( hfind );
#else
	DIR* dirp = opendir(path);
	if( dirp==NULL ){
		errno = ENOENT;
		return -1;
	}
	struct dirent * dp = readdir(dirp);
	while( dp ){
		char path_file[_MAX_PATH];
		dir_cat( path, dp->d_name, path_file, ELEMENTS(path_file) );
		if( IsDirExist(path_file) ){
			if( strcmp(dp->d_name, ".")!=0 && strcmp(dp->d_name, "..")!=0 ){
				if( erase_dir( path_file, true )!=0 ){
					closedir(dirp);
					return -1;
				}
			}
		}else{
			if( remove(path_file)!=0 ){
				closedir(dirp);
				return -1;
			}
		}
		dp = readdir(dirp);
	}
	closedir(dirp);
#endif
	if( rm_cur ){
		return rmdir( path );
	}
	return 0;
}
Ejemplo n.º 10
0
		BOOL IsFileExist(LPCTSTR szFilePath)
		{
			return IsExist(szFilePath) && !IsDirExist(szFilePath);
		}
Ejemplo n.º 11
0
void WriteApplicationFile(char *mappname,char* MessageString)
{
	try
	{
		char mmCurentDir[512];
		SYSTEMTIME systime;

		
		char mdate[255]={0};
		char mmdate[255]={0};
		char mtime[255]={0};
		char mmFileName[512]={0};
		bool isFileExist;
		char mlogtype[1024]={0};
		bool isPerDeleted=false;
		
		//lstrcpy(mmCurentDir , mAPPLOG);
		//strcpy(mmCurentDir,SAAZODSetUpPath);
		lstrcat(mmCurentDir ,"ApplicationLog\\");
		//strcat(mmCurentDir , "\\Log");

		GetLocalTime(&systime);

		sprintf(mdate  , "%04d-%02d-%02d" ,systime.wYear, systime.wDay , systime.wMonth );
		sprintf(mmdate , "%04d%02d%02d" ,systime.wYear, systime.wDay , systime.wMonth);
		//GetTimeFormat(LOCALE_SYSTEM_DEFAULT , NULL , &systime , "hh':'mm':'ss" , mtime , 255);
		sprintf(mtime , "%02d:%02d:%02d" , systime.wHour, systime.wMinute , systime.wSecond);
		sprintf(mmFileName , "%s\\%s.Log" , mmCurentDir , mappname);
		FILE *fp=NULL;

		if(IsDirExist(mmFileName) == false)
		{
			isFileExist = false;
			fp=fopen( mmFileName ,"w+"); //for wiping out the contents
			_fcloseall( );
		}
		else
		{
			isFileExist = true;
		}

		DWORD dwFileSize = IsFile2MB(mmFileName);// Check for 2 MB (2097152 Bytes)

		if(dwFileSize >= 2097152)
		{
			isPerDeleted = true;
			isFileExist = false;
			fp=fopen( mmFileName ,"w+"); //For wiping out the contents
			_fcloseall( );
		}
		
		fp = fopen( mmFileName , "a");
		if(!(fp == NULL))
		{
			if (isFileExist == false)
			{
				fprintf(fp , "#Software: %s\n#Version: 1.0 \n#Date: %s %s\n# \n" , "zSmart.exe", mdate , mtime);
				fprintf(fp , "----------------------------------------------------------------------\n" );
				//fprintf(fp , "#Fields:\tdtime\tSession Id\tSession User Name\tmodule\n");
				if(isPerDeleted == true)
				{
					fprintf(fp , "Previous content is deleted. Due to the size limit of 2 MB\n" );
					fprintf(fp , "----------------------------------------------------------------------\n" );
				}
			}

				
			fprintf(fp , "%s %s\t%s \n" , mdate , mtime , MessageString);
		
		}
		else
		{ 

		}
		_fcloseall( );
	}
	catch(...)
	{
	}
}
/* convert normal file path to secure storage file path  */
int ConvertFileName(int sender_pid, char* dest, const char* src, ssm_flag flag, const char* group_id)
{
	char* if_pointer = NULL;
	unsigned short h_code = 0;
	unsigned short h_code2 = 0;
	unsigned char path_hash[SHA_DIGEST_LENGTH + 1];
	char s[33+1];
	const char* dir = NULL;
	char tmp_cmd[32] = {0, };
	char tmp_buf[10] = {0, };
	const unsigned char exe_path[256] = {0, };
	FILE* fp_proc = NULL;
	char* preserved_dir = NULL;
	int is_dir_exist = -1;

	if(!dest || !src)
	{
		SLOGE( "[%s] Parameter error in ConvertFileName()...\n", __func__);
		return SS_FILE_OPEN_ERROR;	// file related error
	}

	memset(tmp_cmd, 0x00, 32);
	snprintf(tmp_cmd, 32, "/proc/%d/cmdline", sender_pid);

	if(!(fp_proc = fopen(tmp_cmd, "r")))
	{
		SLOGE("[%s] file open error: [%s]", __func__, tmp_cmd);
		return SS_FILE_OPEN_ERROR;
	}
	
	fgets((char*)exe_path, 256, fp_proc);
	fclose(fp_proc);

	if(!strncmp(group_id, "NOTUSED", 7))	// don't share
	{
		h_code2 = GetHashCode(exe_path);
		memset(tmp_buf, 0x00, 10);
		snprintf(tmp_buf, 10, "%u", h_code2);
		dir = tmp_buf;
	}
	else	// share
		dir = group_id;

	if_pointer = strrchr(src, '/');
	
	if(flag == SSM_FLAG_DATA) // /opt/share/secure-storage/*
	{
		// check whether directory is exist or not
		is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);
		
		if (is_dir_exist == 0) // SS_STORAGE_FILE_PATH is not exist
		{
			SLOGI("[%s] directory [%s] is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
			if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0)	// fail to make directory
			{
				SLOGE("[%s] [%s] cannot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
				return SS_FILE_OPEN_ERROR;
			}
		}
		else if (is_dir_exist == -1) // Unknown error
		{
			SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
			return SS_PARAM_ERROR;
		}

		// TBD
		strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
		strncat(dest, dir, (strlen(dest) - 1));
		strncat(dest, "/", 1);

		// make directory
		dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
		is_dir_exist = IsDirExist(dest);

		if(is_dir_exist == 0) // not exist
		{
			SLOGI("[%s] %s is making now.\n", __func__, dest);
			if(mkdir(dest, 0700) < 0)	// fail to make directory
			{
				SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
				return SS_FILE_OPEN_ERROR;
			}
		}
		
		strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
		strncat(dest, "_", 1);

		SHA1((unsigned char*)src, (size_t)strlen(src), path_hash);
		h_code = GetHashCode(path_hash);
		memset(s, 0x00, 34);
		snprintf(s, 34, "%u", h_code);
		strncat(dest, s, strlen(s));
		strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));

		dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(if_pointer) + strlen(s) + strlen(SS_FILE_POSTFIX) + 4] = '\0';
	}
	else if(flag == SSM_FLAG_SECRET_PRESERVE) // /tmp/csa/
	{
		preserved_dir = get_preserved_dir();
		if(preserved_dir == NULL)	// fail to get preserved directory
		{
			SLOGE("[%s] fail to get preserved dir\n", __func__);
			return SS_FILE_OPEN_ERROR;
		}
		
		if(strncmp(src, preserved_dir, strlen(preserved_dir)) == 0) //src[0] == '/')
		{
			strncpy(dest, src, MAX_FILENAME_LEN - 1);
			strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));

			dest[strlen(src) + strlen(SS_FILE_POSTFIX)] = '\0';
		}
		else if(if_pointer != NULL)	// absolute path == file
		{
			strncpy(dest, preserved_dir, MAX_FILENAME_LEN - 1);
			strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
			strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
			dest[strlen(preserved_dir) + strlen(if_pointer) + strlen(SS_FILE_POSTFIX) + 1] = '\0';
		}
		else	// relative path == buffer
		{
			strncpy(dest, preserved_dir, MAX_FILENAME_LEN - 1);
			strncat(dest, src, strlen(src));
			strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
			dest[strlen(preserved_dir) + strlen(src) + strlen(SS_FILE_POSTFIX)] = '\0';
		}

		free(preserved_dir);

	}
	else if(flag == SSM_FLAG_SECRET_OPERATION) // /opt/share/secure-storage/
	{
		if(if_pointer != NULL) 	// absolute path == input is a file
		{
			// check whether directory is exist or not
			is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);

			if (is_dir_exist == 0) // SS_STORAGE_FILE_PATH is not exist
			{
				SLOGI("[%s] %s is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
				if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0)	// fail to make directory
				{
					SLOGE("[%s] [%s] cannnot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
					return SS_FILE_OPEN_ERROR;
				}
			}
			else if (is_dir_exist == -1) // Unknown error
			{
				SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
				return SS_PARAM_ERROR;
			}
			
			strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
			strncat(dest, dir, strlen(dir));
			strncat(dest, "/", 1);

			// make directory
			dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
			is_dir_exist = IsDirExist(dest);

			if(is_dir_exist == 0) // not exist
			{
				SLOGI("[%s] %s is making now.\n", __func__, dest);
				if(mkdir(dest, 0700) < 0)
				{
					SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
					return SS_FILE_OPEN_ERROR;
				}
			}
			
			strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
			strncat(dest, "_", 1);
			SHA1((unsigned char*)src, (size_t)strlen(src), path_hash);
			h_code = GetHashCode(path_hash);
			memset(s, 0x00, 34);
			snprintf(s, 34, "%u", h_code);
			strncat(dest, s, strlen(s));
			strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));

			dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(if_pointer) + strlen(s) + strlen(SS_FILE_POSTFIX) + 4] = '\0';
		}
		else	// relative path == input is a buffer
		{
			// check whether directory is exist or not
			is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);

			if (is_dir_exist == 0) // SS_STORAGE_BUFFER_PATH is not exist
			{
				SLOGI("[%s] %s is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
				if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0)
				{
					SLOGE("[%s] [%s] cannot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
					return SS_FILE_OPEN_ERROR;
				}
			}
			else if (is_dir_exist == -1) // Unknown error
			{
				SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
				return SS_PARAM_ERROR;
			}

			strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
			strncat(dest, dir, strlen(dir));
			strncat(dest, "/", 1);

			// make directory
			dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
			is_dir_exist = IsDirExist(dest);

			if(is_dir_exist == 0) // not exist
			{
				SLOGI("[%s] %s is making now.\n", __func__, dest);
				if(mkdir(dest, 0700) < 0)
				{
					SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
					return SS_FILE_OPEN_ERROR;
				}
			}

			strncat(dest, src, strlen(src));
			strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));

			dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(src) + strlen(SS_FILE_POSTFIX) + 2] = '\0';
		}
	}
	else
	{
		SLOGE("[%s] flag mispatch. cannot convert file name.\n", __func__);
		return SS_PARAM_ERROR;
	}

	return 1;
}