int execute_cd(char** words) {
if(words == NULL){
return EXIT_FAILURE;
}
if(words[0] == NULL){
return EXIT_FAILURE;
}
if(words[1] == NULL){
return EXIT_FAILURE;
}
if(strcmp(words[0], "cd")!= 0){
return EXIT_FAILURE;
}
char path[MAX_DIRNAME];
strcpy(path, words[1]);
char currentdir[MAX_DIRNAME];
if(is_relative(words[1]) == 1){
getcwd(currentdir, sizeof(currentdir));
strcat(currentdir, "/");
strcat(currentdir, words[1]);
chdir(currentdir);
return 0;
}
else if(is_relative(words[1]) == 0){
chdir(words[1]);
return 0;
}
else{
return EXIT_FAILURE;
}
}
void web_crawler::job_downloader(web_crawler::urls_t& urls, web_crawler::pages_t& pages)
{
while (!urls.empty())
{
uri::uri url = urls.front();
urls.pop();
std::cout << url.string() <<std::endl;
if (pages.find(url) != pages.end())
{
std::cout << "url already processed " <<std::endl;
continue;
}
if (!url.is_valid())
{
std::cout << "invalid url " <<std::endl;
continue;
}
try
{
thread_local http::client client;
http::client::response response;
auto request = http::client::request(url);
response = client.get(request);
auto st = status(response);
if (st > 400)
{
std::cout << "error " << st <<std::endl;
continue;
}
const auto page = body(response);
auto links = search_for_links(page);
std::remove_if(links.begin(), links.end(), [&pages](const uri::uri& link) {
return pages.find(link) == pages.end();
});
for (const auto& link : links)
{
auto url_to_push = is_relative(link) ? link.string() : url.string() + link.string();
urls.push(url_to_push);
}
pages[url] = page;
cv.notify_all();
}
catch(std::exception& e)
{
std::cout<<"error " << e.what()<<std::endl;
std::cout <<urls.size() << " " <<pages.size() <<std::endl;
urls.push(url);
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
continue;
}
}
}
/**
* Changes directory to a path specified in the words argument;
* For example: words[0] = "cd"
* words[1] = "csc209/assignment3/"
* Your command should handle both relative paths to the current
* working directory, and absolute paths relative to root,
* e.g., relative path: cd csc209/assignment3/
* absolute path: cd /u/bogdan/csc209/assignment3/
*/
int execute_cd(char** words) {
/**
* The first word contains the "cd" string, the second one contains
* the path.
* Check possible errors:
* - The words pointer could be NULL, the first string or the second
* string could be NULL, or the first string is not a cd command
* - If so, return an EXIT_FAILURE status to indicate something is
* wrong.
*/
if(!words || !words[0] || !words[1] || strcmp(words[0], "cd")) {
return EXIT_FAILURE;
}
/**
* Change directory to words[1], and return the result of that
* chdir call. If the directory to be changed to (words[1] or
* the cwd plus '/' and words[1]) is too long, return
* EXIT_FAILURE
*/
if(is_relative(words[1])) {
char dir[MAX_DIRNAME];
getcwd(dir, MAX_DIRNAME);
if (strlen(words[1]) + strlen(dir) + 1 >= MAX_DIRNAME) {
return EXIT_FAILURE;
}
} else {
if(strlen(words[1]) >= MAX_DIRNAME) {
return EXIT_FAILURE;
}
}
return chdir(words[1]);
}
double tolupp(std::string str, double sign)
{
size_t start = 0;
reltypes_et reltype;
double val1, val2, factor;
reltype = is_relative(str);
if(ABS==reltype){
// absolute tolerance value
// first number
val1 = norm_value(str,start);
//second number
val2 = norm_value(str,start);
if(isnan(val2)) return sign*abs(val1); // if only one value - negative lower bound
if(sign*val2>sign*val1) return val2;
return val1;
}else{
//relative tolerance value
factor = getfactor(reltype);
// first number
val1 = getval(str,start) * factor;
//second number
val2 = getval(str,start) * factor;
if(isnan(val2)) return sign*abs(val1); // if only one value - negative lower bound
if(sign*val2>sign*val1) return val2;
return val1;
}
}
/** \brief return the number of level of this file_path2_t
*/
size_t file_path2_t::size() const throw()
{
if( is_relative() ){
if( name_db[0] == FS_DIR_PLACEHOLDER ) return name_db.size();
return name_db.size() + 1;
}
return name_db.size();
}
/** \brief return the name at idx in this file_path2_t
*/
file_path2_t file_path2_t::operator[](size_t idx) const throw()
{
if( is_relative() ){
if( idx == 0 ) return FS_DIR_PLACEHOLDER;
if( name_db[0] != FS_DIR_PLACEHOLDER ) idx--;
}else{
if( idx == 0 ) return FS_DIR_SEPARATOR;
}
return name_db[idx];
}
path path::relative_path() const {
// first pathname *after* the root path
// root_path is first / in this implementation.
if (is_relative()) return *this;
auto pos = _path.find_first_not_of(separator);
if (pos == _path.npos) return path();
return path(_path.substr(pos));
}
/** Update the include path
*
* @return include filepaths
*
* The include path are the directories, in which all includes will be
* searched for.
*/
const std::vector<std::string>&
KeyFile::get_include_dirs(bool _update)
{
if (!_update)
return include_dirs;
// lets take the long way ...
std::set<std::string> new_include_dirs;
// dir of file
std::string directory = "";
auto my_filepath = get_filepath();
size_t pos = my_filepath.find_last_of("/\\");
if (pos != std::string::npos)
directory = my_filepath.substr(0, pos) + "/";
if (!directory.empty())
new_include_dirs.insert(directory);
// update
for (auto& kw : include_path_keywords) {
auto kw_inc_path = std::static_pointer_cast<IncludePathKeyword>(kw);
bool is_relative_dir = kw_inc_path->is_relative();
// append
for (const auto& dirpath : kw_inc_path->get_include_dirs()) {
if (is_relative_dir)
new_include_dirs.insert(join_path(directory, dirpath));
else
new_include_dirs.insert(dirpath);
}
}
// check also the includes
for (auto& include_kw : include_keywords)
for (auto& include_kf : include_kw->get_includes()) {
auto paths = include_kf->get_include_dirs(true);
new_include_dirs.insert(paths.begin(), paths.end());
}
#ifdef QD_DEBUG
std::cout << "Include dirs:\n";
for (const auto& entry : include_dirs)
std::cout << entry << '\n';
#endif
include_dirs =
std::vector<std::string>(new_include_dirs.begin(), new_include_dirs.end());
return include_dirs;
}
string Uri::get_authority( void ) const
{
string authority = String::empty;
if ( is_relative( ) ) return authority;
smatch match;
static const regex pattern( "^[a-zA-Z][a-zA-Z0-9+\\-.]*://(([a-zA-Z0-9\\-._~%!$&'()*+,;=]+)(:([a-zA-Z0-9\\-._~%!$&'()*+,;=]+))?@)?([a-zA-Z0-9\\-._~%]+|\\[[a-zA-Z0-9\\-._~%!$&'()*+,;=:]+\\])" );
if ( regex_search( m_pimpl->m_uri, match, pattern ) ) authority = match[ 5 ];
if ( authority.front( ) == '[' ) authority.erase( 0, 1 );
if ( authority.back( ) == ']' ) authority.erase( authority.length( ) - 1, 1 );
return authority;
}
/** \brief Return the fullpath2 of this file_path2_t
*
* - WARNING: this function assume that the file_path2_t is relative to the
* *CURRENT* directory !
* - so if the file_path2_t is created for with a relative path2 with a given
* current directory, then the current directory is changed, and then
* fullpath2() is called, it will return the full path2 in the SECOND
* current directory
*/
file_path2_t file_path2_t::fullpath2() const throw()
{
// if this file_path2_t is already 'absolute', return it as is
if( is_absolute() ) return *this;
// sanity check - here the
DBG_ASSERT( is_relative() );
#if 0
// prepend the current directory to this relative path2
return file_utils_t::get_current_dir() / *this;
#else
// EXP_ASSERT(0);
KLOG_ERR("file_utils_t::get_current_dir() return file_path_t. so wont work for file_path2_t");
return file_path2_t();
#endif
}
CL_String CL_PathHelp::make_relative(
const CL_String &base_path,
const CL_String &absolute_path,
PathType path_type)
{
CL_String base = add_trailing_slash(normalize(base_path, path_type), path_type);
CL_String absolute = normalize(absolute_path, path_type);
if (path_type == path_type_file)
{
CL_String base_location = get_location(base, path_type_file);
CL_String absolute_location = get_location(absolute, path_type_file);
if (is_relative(base, path_type))
{
#ifdef WIN32
if (base_location.length() == 2 && base_location[1] == ':')
{
int drive = 0;
if (base_location[0] >= 'A' && base_location[0] <= 'Z')
drive = base_location[0] - 'A' + 1;
else if (base_location[0] >= 'a' && base_location[0] <= 'z')
drive = base_location[0] - 'a' + 1;
else
throw CL_Exception(cl_format("Invalid drive: %1", base_location));
TCHAR working_dir[MAX_PATH];
memset(working_dir, 0, sizeof(TCHAR)*MAX_PATH);
if (_tgetdcwd(drive, working_dir, MAX_PATH) == 0)
throw CL_Exception(cl_format("Unable to get current working directory for %1!", base_location));
base = add_trailing_slash(working_dir, path_type) + base;
}
else if (base_location.empty())
{
TCHAR working_dir[MAX_PATH];
memset(working_dir, 0, sizeof(TCHAR)*MAX_PATH);
if (GetCurrentDirectory(MAX_PATH, working_dir) == FALSE)
throw CL_Exception(cl_format("Unable to get current working directory for %1!", base_location));
base = add_trailing_slash(working_dir, path_type) + base;
}
else
{
throw CL_Exception(cl_format("Error in make_relative with base path: %1", base_path));
}
#else
char working_dir[1024];
memset(working_dir, 0, 1024);
if (getcwd(working_dir, 1024) == 0)
throw CL_Exception("Unable to get current working directory!");
base = add_trailing_slash(working_dir, path_type) + base;
#endif
}
if (is_relative(absolute, path_type))
{
#ifdef WIN32
if (absolute_location.length() == 2 && absolute_location[1] == ':')
{
int drive = 0;
if (absolute_location[0] >= 'A' && absolute_location[0] <= 'Z')
drive = absolute_location[0] - 'A' + 1;
else if (absolute_location[0] >= 'a' && absolute_location[0] <= 'z')
drive = absolute_location[0] - 'a' + 1;
else
throw CL_Exception(cl_format("Invalid drive: %1", absolute_location));
TCHAR working_dir[MAX_PATH];
memset(working_dir, 0, sizeof(TCHAR)*MAX_PATH);
if (_tgetdcwd(drive, working_dir, MAX_PATH) == 0)
throw CL_Exception(cl_format("Unable to get current working directory for %1!", absolute_location));
absolute = add_trailing_slash(working_dir, path_type) + absolute;
}
else if (absolute_location.empty())
{
TCHAR working_dir[MAX_PATH];
memset(working_dir, 0, sizeof(TCHAR)*MAX_PATH);
if (GetCurrentDirectory(MAX_PATH, working_dir) == FALSE)
throw CL_Exception(cl_format("Unable to get current working directory for %1!", absolute_location));
absolute = add_trailing_slash(working_dir, path_type) + absolute;
}
else
{
throw CL_Exception(cl_format("Error in make_relative with absolute path: %1", absolute_path));
}
#else
char working_dir[1024];
memset(working_dir, 0, 1024);
if (getcwd(working_dir, 1024) == 0)
throw CL_Exception("Unable to get current working directory!");
absolute = add_trailing_slash(working_dir, path_type) + absolute;
#endif
}
base_location = get_location(base, path_type_file);
absolute_location = get_location(absolute, path_type_file);
if (CL_StringHelp::compare(absolute_location, base_location, true) != 0)
return absolute_path;
}
if (is_relative(base, path_type))
throw CL_Exception(cl_format("Relative path %1 used as base path for make_relative", base_path));
if (is_relative(absolute, path_type))
throw CL_Exception(cl_format("Relative path %1 used as absolute path for make_relative", absolute_path));
CL_String relative;
CL_String relative_end;
bool differs = false;
CL_String::size_type start_pos = 0, end_pos = 0;
while (true)
{
if (path_type == path_type_file)
{
end_pos = base.find_first_of("\\/", start_pos);
}
else
{
end_pos = base.find('/', start_pos);
}
if (end_pos == CL_String::npos)
break;
if (!differs)
{
CL_String base_element = base.substr(start_pos, end_pos - start_pos + 1);
CL_String absolute_element = absolute.substr(start_pos, end_pos - start_pos + 1);
bool same_element = false;
if (path_type == path_type_file)
{
#ifdef WIN32
same_element = (CL_StringHelp::compare(base_element, absolute_element, true) == 0);
#else
same_element = (base_element == absolute_element);
#endif
}
else
{
same_element = (base_element == absolute_element);
}
if (!same_element)
{
relative_end = absolute.substr(start_pos);
differs = true;
}
else
{
relative_end = absolute.substr(end_pos+1);
}
}
if (differs)
{
if (path_type_file)
{
#ifdef WIN32
relative += "..\\";
#else
relative += "../";
#endif
}
else
{
relative += "../";
}
}
start_pos = end_pos + 1;
}
return relative + relative_end;
}
void
HOSTFXR_UTILITY::GetHostFxrParameters(
const fs::path &processPath,
const fs::path &applicationPhysicalPath,
const std::wstring &applicationArguments,
fs::path &hostFxrDllPath,
fs::path &dotnetExePath,
std::vector<std::wstring> &arguments
)
{
LOG_INFOF(L"Resolving hostfxr parameters for application: '%ls' arguments: '%ls' path: '%ls'",
processPath.c_str(),
applicationArguments.c_str(),
applicationPhysicalPath.c_str());
arguments = std::vector<std::wstring>();
fs::path expandedProcessPath = Environment::ExpandEnvironmentVariables(processPath);
const auto expandedApplicationArguments = Environment::ExpandEnvironmentVariables(applicationArguments);
LOG_INFOF(L"Known dotnet.exe location: '%ls'", dotnetExePath.c_str());
if (!expandedProcessPath.has_extension())
{
// The only executable extension inprocess supports
expandedProcessPath.replace_extension(".exe");
}
else if (!ends_with(expandedProcessPath, L".exe", true))
{
throw InvalidOperationException(format(L"Process path '%s' doesn't have '.exe' extension.", expandedProcessPath.c_str()));
}
// Check if the absolute path is to dotnet or not.
if (IsDotnetExecutable(expandedProcessPath))
{
LOG_INFOF(L"Process path '%ls' is dotnet, treating application as portable", expandedProcessPath.c_str());
if (applicationArguments.empty())
{
throw InvalidOperationException(L"Application arguments are empty.");
}
if (dotnetExePath.empty())
{
dotnetExePath = GetAbsolutePathToDotnet(applicationPhysicalPath, expandedProcessPath);
}
hostFxrDllPath = GetAbsolutePathToHostFxr(dotnetExePath);
arguments.push_back(dotnetExePath);
AppendArguments(
expandedApplicationArguments,
applicationPhysicalPath,
arguments,
true);
}
else
{
LOG_INFOF(L"Process path '%ls' is not dotnet, treating application as standalone or portable with bootstrapper", expandedProcessPath.c_str());
auto executablePath = expandedProcessPath;
if (executablePath.is_relative())
{
executablePath = applicationPhysicalPath / expandedProcessPath;
}
//
// The processPath is a path to the application executable
// like: C:\test\MyApp.Exe or MyApp.Exe
// Check if the file exists, and if it does, get the parameters for a standalone application
//
if (is_regular_file(executablePath))
{
auto applicationDllPath = executablePath;
applicationDllPath.replace_extension(".dll");
LOG_INFOF(L"Checking application.dll at '%ls'", applicationDllPath.c_str());
if (!is_regular_file(applicationDllPath))
{
throw InvalidOperationException(format(L"Application .dll was not found at %s", applicationDllPath.c_str()));
}
hostFxrDllPath = executablePath.parent_path() / "hostfxr.dll";
LOG_INFOF(L"Checking hostfxr.dll at '%ls'", hostFxrDllPath.c_str());
if (is_regular_file(hostFxrDllPath))
{
LOG_INFOF(L"hostfxr.dll found app local at '%ls', treating application as standalone", hostFxrDllPath.c_str());
// For standalone apps we need .exe to be argv[0], dll would be discovered next to it
arguments.push_back(executablePath);
}
else
{
LOG_INFOF(L"hostfxr.dll found app local at '%ls', treating application as portable with launcher", hostFxrDllPath.c_str());
// passing "dotnet" here because we don't know where dotnet.exe should come from
// so trying all fallbacks is appropriate
if (dotnetExePath.empty())
{
dotnetExePath = GetAbsolutePathToDotnet(applicationPhysicalPath, L"dotnet");
}
hostFxrDllPath = GetAbsolutePathToHostFxr(dotnetExePath);
// For portable with launcher apps we need dotnet.exe to be argv[0] and .dll be argv[1]
arguments.push_back(dotnetExePath);
arguments.push_back(applicationDllPath);
}
AppendArguments(
expandedApplicationArguments,
applicationPhysicalPath,
arguments);
}
else
{
//
// If the processPath file does not exist and it doesn't include dotnet.exe or dotnet
// then it is an invalid argument.
//
throw InvalidOperationException(format(L"Executable was not found at '%s'", executablePath.c_str()));
}
}
}
// The processPath ends with dotnet.exe or dotnet
// like: C:\Program Files\dotnet\dotnet.exe, C:\Program Files\dotnet\dotnet, dotnet.exe, or dotnet.
// Get the absolute path to dotnet. If the path is already an absolute path, it will return that path
fs::path
HOSTFXR_UTILITY::GetAbsolutePathToDotnet(
const fs::path & applicationPath,
const fs::path & requestedPath
)
{
LOG_INFOF(L"Resolving absolute path to dotnet.exe from '%ls'", requestedPath.c_str());
auto processPath = requestedPath;
if (processPath.is_relative())
{
processPath = applicationPath / processPath;
}
//
// If we are given an absolute path to dotnet.exe, we are done
//
if (is_regular_file(processPath))
{
LOG_INFOF(L"Found dotnet.exe at '%ls'", processPath.c_str());
return processPath;
}
// At this point, we are calling where.exe to find dotnet.
// If we encounter any failures, try getting dotnet.exe from the
// backup location.
// Only do it if no path is specified
if (requestedPath.has_parent_path())
{
LOG_INFOF(L"Absolute path to dotnet.exe was not found at '%ls'", requestedPath.c_str());
throw InvalidOperationException(format(L"Could not find dotnet.exe at '%s'", processPath.c_str()));
}
const auto dotnetViaWhere = InvokeWhereToFindDotnet();
if (dotnetViaWhere.has_value())
{
LOG_INFOF(L"Found dotnet.exe via where.exe invocation at '%ls'", dotnetViaWhere.value().c_str());
return dotnetViaWhere.value();
}
const auto programFilesLocation = GetAbsolutePathToDotnetFromProgramFiles();
if (programFilesLocation.has_value())
{
LOG_INFOF(L"Found dotnet.exe in Program Files at '%ls'", programFilesLocation.value().c_str());
return programFilesLocation.value();
}
LOG_INFOF(L"dotnet.exe not found");
throw InvalidOperationException(format(
L"Could not find dotnet.exe at '%s' or using the system PATH environment variable."
" Check that a valid path to dotnet is on the PATH and the bitness of dotnet matches the bitness of the IIS worker process.",
processPath.c_str()));
}
