string get_file_full_path(string file_path,string cur_dir)
{
//xuegang 5种情况
if(cur_dir=="") cur_dir=get_current_dir();
if(file_path.size()<2) return file_path;
if(file_path[0]=='.')
{
if(file_path[1]=='.')// ../../dir/file
{
if(file_path.size()<3) return "";
else if(file_path[2]!='\\' && file_path[2]!='/') return "";
return get_file_full_path(file_path.erase(0,3),get_parent_dir(cur_dir));
}
else if(file_path[1]=='\\' || file_path[1]=='/')// ./dir/file
{
return cur_dir+file_path.erase(0,1);
}
else return "";
}
else if(file_path[0]=='\\')// \dir/file
{
return cur_dir.substr(0,2)+file_path;
}
else if(file_path[1]==':')// c:/dir/file
{
return file_path;
}
else// dir/file
{
return cur_dir+"/"+file_path;
}
}
void Ui_MainWindow::_open_bubble(int drv, const QString fname)
{
char path_shadow[PATH_MAX];
int i;
if(fname.length() <= 0) return;
drv = drv & 7;
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
UPDATE_HISTORY(path_shadow, config.recent_bubble_casette_path[drv], listBubbles[drv]);
get_parent_dir(path_shadow);
strcpy(config.initial_bubble_casette_dir, path_shadow);
// Update List
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
if(emu) {
emit sig_close_bubble(drv);
//emu->LockVM();
emit sig_open_bubble(drv, fname, 0);
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
if(check_file_extension(path_shadow, ".b77")) {
UPDATE_B77_LIST(drv, listB77[drv]);
menu_bubbles[drv]->do_update_inner_media_bubble(listB77[drv], 0);
} else {
menu_bubbles[drv]->do_clear_inner_media();
}
}
}
int Ui_MainWindow::set_recent_bubble(int drv, int num)
{
QString s_path;
char path_shadow[PATH_MAX];
int i;
if((num < 0) || (num >= MAX_HISTORY)) return -1;
s_path = QString::fromLocal8Bit(config.recent_bubble_casette_path[drv][num]);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
UPDATE_HISTORY(path_shadow, config.recent_bubble_casette_path[drv], listBubbles[drv]);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
get_parent_dir(path_shadow);
strcpy(config.initial_bubble_casette_dir, path_shadow);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
if(emu) {
emit sig_close_bubble(drv);
emit sig_open_bubble(drv, s_path, 0);
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
if(check_file_extension(path_shadow, ".b77")) {
UPDATE_B77_LIST(drv, listB77[drv]);
menu_bubbles[drv]->do_update_inner_media_bubble(listB77[drv], 0);
} else {
menu_bubbles[drv]->do_clear_inner_media();
}
}
return 0;
}
// Given the path to our python executable, load the binary and check
// the processor architecture. If it's an x64 binary and our current
// executable isn't, we'll return 0.
static int is_valid(char* python)
{
char sPythonDir[MAX_PATH+1] = {0};
int result = 1;
LOADED_IMAGE oImg;
ZeroMemory(&oImg, sizeof(oImg));
if(!get_parent_dir(python, sPythonDir, MAX_PATH)) {
debug("Could not get parent folder of %s..", python);
return 0;
}
if(!MapAndLoad(PYTHON_EXE, sPythonDir, &oImg, 0, 1)) {
debug("Could not MapAndLoad %s. Used folder: %s", PYTHON_EXE, sPythonDir);
return 0;
}
switch(oImg.FileHeader->FileHeader.Machine)
{
case IMAGE_FILE_MACHINE_IA64:
#ifdef _M_IA64
result = 1;
#else
result = 0;
Platform_Mismatch("IA64");
#endif
break;
// AMD64
case IMAGE_FILE_MACHINE_AMD64:
#ifdef _M_X64
result = 1;
#else
result = 0;
Platform_Mismatch("X64");
#endif
break;
// X86 (32-bit)
case IMAGE_FILE_MACHINE_I386:
#ifdef _M_IX86
result = 1;
#else
result = 0;
Platform_Mismatch("X86");
#endif
break;
// IA64
default:
result = 0;
Platform_Mismatch("Invalid");
break;
}
// This shouldn't happen, but you never know.
if(!UnMapAndLoad(&oImg)) {
debug("Could not unmap the python image.");
return 0;
}
return result;
}
bool fs::create_path(const std::string& path)
{
const auto& parent = get_parent_dir(path);
if (!parent.empty() && !is_dir(parent) && !create_path(parent))
{
return false;
}
return create_dir(path);
}
int Ui_MainWindow::set_recent_disk(int drv, int num)
{
QString s_path;
char path_shadow[PATH_MAX];
int i;
if((num < 0) || (num >= MAX_HISTORY)) return -1;
s_path = QString::fromLocal8Bit(config.recent_floppy_disk_path[drv][num]);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
UPDATE_HISTORY(path_shadow, config.recent_floppy_disk_path[drv], listFDs[drv]);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
get_parent_dir(path_shadow);
strcpy(config.initial_floppy_disk_dir, path_shadow);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
if(emu) {
emit sig_close_disk(drv);
emit sig_open_disk(drv, s_path, 0);
menu_fds[drv]->do_update_histories(listFDs[drv]);
menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
UPDATE_D88_LIST(drv, listD88[drv]);
menu_fds[drv]->do_update_inner_media(listD88[drv], 0);
} else {
menu_fds[drv]->do_clear_inner_media();
}
if(using_flags->get_max_drive() >= 2) {
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
if(((drv & 1) == 0) && (drv + 1 < using_flags->get_max_drive()) && (1 < emu->d88_file[drv].bank_num)) {
int drv2 = drv + 1;
emit sig_close_disk(drv2);
emit sig_open_disk(drv2, s_path, 1);
menu_fds[drv2]->do_update_histories(listFDs[drv2]);
menu_fds[drv2]->do_set_initialize_directory(config.initial_floppy_disk_dir);
UPDATE_D88_LIST(drv2, listD88[drv2]);
menu_fds[drv2]->do_update_inner_media(listD88[drv2], 1);
}
}
}
}
return 0;
}
void Ui_MainWindow::_open_disk(int drv, const QString fname)
{
char path_shadow[PATH_MAX];
int i;
if(fname.length() <= 0) return;
drv = drv & 7;
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
UPDATE_HISTORY(path_shadow, config.recent_floppy_disk_path[drv], listFDs[drv]);
get_parent_dir(path_shadow);
strcpy(config.initial_floppy_disk_dir, path_shadow);
// Update List
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
if(emu) {
emit sig_close_disk(drv);
//emu->LockVM();
emit sig_open_disk(drv, fname, 0);
menu_fds[drv]->do_update_histories(listFDs[drv]);
menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
UPDATE_D88_LIST(drv, listD88[drv]);
menu_fds[drv]->do_update_inner_media(listD88[drv], 0);
} else {
menu_fds[drv]->do_clear_inner_media();
}
}
if(using_flags->get_max_drive() >= 2) {
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
if(((drv & 1) == 0) && (drv + 1 < using_flags->get_max_drive()) && (1 < emu->d88_file[drv].bank_num)) {
int drv2 = drv + 1;
emit sig_close_disk(drv2);
//emu->LockVM();
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
emit sig_open_disk(drv2, fname, 1);
menu_fds[drv2]->do_update_histories(listFDs[drv2]);
menu_fds[drv2]->do_set_initialize_directory(config.initial_floppy_disk_dir);
UPDATE_D88_LIST(drv2, listD88[drv2]);
menu_fds[drv2]->do_update_inner_media(listD88[drv2], 1);
}
}
}
}
void FileList::s_cd_parent_dir()
{
QString parent_dir_str;
get_parent_dir(cur_dir_, parent_dir_str);
//int ret = QMessageBox::warning(this, "s_cd_parent_dir()", parent_dir_str, QMessageBox::Save | QMessageBox::Cancel, QMessageBox::Save);
qDebug("parent_dir_str : %s", parent_dir_str.toStdString().c_str() );
if (parent_dir_str == "")
{
cur_dir_="";
list_first_layer_dir();
}
else
{
change_dir(parent_dir_str.toStdString().c_str() );
}
//change_dir(cur_dir_ + QDIR_SEPARATOR +"..");
change_title_to_cur_path();
//QMessageBox::warning("s_cd_par");
}
/**
* @brief lists the directories to be listed by crashenv script
* when one or several directories couldn't have been added to
* inotify watcher.
*
* @param crashenv_param: buffer containing the inotify events
*/
void build_crashenv_dir_list_option( char crashenv_param[PATHMAX] ) {
int idx = 0, idx_parent = 0;
char path[PATHMAX] = { 0, };
char tmp[PATHMAX] = { 0, };
char parent_array[(int)DIM(wd_array)][PATHMAX];
crashenv_param[0] = '\0';
for (idx = 0 ; idx < (int)DIM(wd_array) ; idx++) {
if (wd_array[idx].wd >= 0 && wd_array[idx].inotify_error == 0) continue; /* Skip if well watched */
if ( get_parent_dir( wd_array[idx].eventpath, path ) != 0 ) {
LOGD("%s : error - can't get parent path of %s\n", __FUNCTION__, wd_array[idx].eventpath);
continue;
}
/* Skip path if same parent path already got */
int alreadydone = 0, j;
for (j = 0 ; j < idx_parent ; j++) {
if ( !strcmp(path, parent_array[j]) ) {
alreadydone = 1;
break;
}
}
if (alreadydone) continue;
/* Add path to parent_array to manage duplicates and add path to output param string */
strncpy(parent_array[idx_parent], path, PATHMAX-1);
idx_parent++;
snprintf( tmp, sizeof(tmp), "-l %s ", path);
if( PATHMAX-1 - strlen(crashenv_param) >= strlen(tmp) )
strncat( crashenv_param, tmp, PATHMAX-1);
else
LOGW("%s : error - can't add path %s in monitor_crashenv -l option : no available space\n",
__FUNCTION__, wd_array[idx].eventpath);
}
return;
}
/**
* Get the expected striping layout for a file at \a path.
*
* Substitute expected inherited attribute values for unspecified
* attributes. Unspecified attributes may belong to directories and
* never-written-to files, and indicate that default values will be
* assigned when files are created or first written to. A default value
* is inherited from the parent directory if the attribute is specified
* there, otherwise it is inherited from the filesystem root.
* Unspecified attributes normally have the value LLAPI_LAYOUT_DEFAULT.
*
* The complete \a path need not refer to an existing file or directory,
* but some leading portion of it must reside within a lustre filesystem.
* A use case for this interface would be to obtain the literal striping
* values that would be assigned to a new file in a given directory.
*
* \param[in] path path for which to get the expected layout
*
* \retval valid llapi_layout pointer on success
* \retval NULL if an error occurs
*/
static struct llapi_layout *llapi_layout_expected(const char *path)
{
struct llapi_layout *path_layout = NULL;
struct llapi_layout *donor_layout;
char donor_path[PATH_MAX];
struct stat st;
int fd;
int rc;
fd = open(path, O_RDONLY);
if (fd < 0 && errno != ENOENT)
return NULL;
if (fd >= 0) {
int tmp;
path_layout = llapi_layout_get_by_fd(fd, 0);
tmp = errno;
close(fd);
errno = tmp;
}
if (path_layout == NULL) {
if (errno != ENODATA && errno != ENOENT)
return NULL;
path_layout = llapi_layout_alloc();
if (path_layout == NULL)
return NULL;
}
if (is_fully_specified(path_layout))
return path_layout;
rc = stat(path, &st);
if (rc < 0 && errno != ENOENT) {
llapi_layout_free(path_layout);
return NULL;
}
/* If path is a not a directory or doesn't exist, inherit unspecified
* attributes from parent directory. */
if ((rc == 0 && !S_ISDIR(st.st_mode)) ||
(rc < 0 && errno == ENOENT)) {
get_parent_dir(path, donor_path, sizeof(donor_path));
donor_layout = llapi_layout_get_by_path(donor_path, 0);
if (donor_layout != NULL) {
inherit_layout_attributes(donor_layout, path_layout);
llapi_layout_free(donor_layout);
if (is_fully_specified(path_layout))
return path_layout;
}
}
/* Inherit remaining unspecified attributes from the filesystem root. */
rc = llapi_search_mounts(path, 0, donor_path, NULL);
if (rc < 0) {
llapi_layout_free(path_layout);
return NULL;
}
donor_layout = llapi_layout_get_by_path(donor_path, 0);
if (donor_layout == NULL) {
llapi_layout_free(path_layout);
return NULL;
}
inherit_layout_attributes(donor_layout, path_layout);
llapi_layout_free(donor_layout);
return path_layout;
}
int wmain (int argc, WCHAR *argv[])
{
SHELLEXECUTEINFOW sei;
WCHAR *args = NULL;
int i;
int unix_mode = 0;
int progid_open = 0;
WCHAR *dos_filename = NULL;
WCHAR *parent_directory = NULL;
DWORD binary_type;
static const WCHAR openW[] = { 'o', 'p', 'e', 'n', 0 };
static const WCHAR unixW[] = { 'u', 'n', 'i', 'x', 0 };
static const WCHAR progIDOpenW[] =
{ 'p', 'r', 'o', 'g', 'I', 'D', 'O', 'p', 'e', 'n', 0};
memset(&sei, 0, sizeof(sei));
sei.cbSize = sizeof(sei);
sei.lpVerb = openW;
sei.nShow = SW_SHOWNORMAL;
/* Dunno what these mean, but it looks like winMe's start uses them */
sei.fMask = SEE_MASK_FLAG_DDEWAIT|
SEE_MASK_FLAG_NO_UI|
SEE_MASK_NO_CONSOLE;
/* Canonical Microsoft commandline flag processing:
* flags start with /, are case insensitive,
* and may be run together in same word.
*/
for (i=1; i<argc; i++) {
int ci;
if (argv[i][0] != '/')
break;
/* Unix paths can start with / so we have to assume anything following /U is not a flag */
if (unix_mode || progid_open)
break;
/* Handle all options in this word */
for (ci=0; argv[i][ci]; ) {
/* Skip slash */
ci++;
switch(argv[i][ci]) {
case 'b':
case 'B':
break; /* FIXME: should stop new window from being created */
case 'i':
case 'I':
break; /* FIXME: should ignore any changes to current environment */
case 'l':
case 'L':
license();
break; /* notreached */
case 'm':
case 'M':
if (argv[i][ci+1] == 'a' || argv[i][ci+1] == 'A')
sei.nShow = SW_SHOWMAXIMIZED;
else
sei.nShow = SW_SHOWMINIMIZED;
break;
case 'r':
case 'R':
/* sei.nShow = SW_SHOWNORMAL; */
break;
case 'u':
case 'U':
if (strncmpiW(&argv[i][ci], unixW, 4) == 0)
unix_mode = 1;
else {
WINE_ERR("Option '%s' not recognized\n", wine_dbgstr_w( argv[i]+ci-1));
usage();
}
break;
case 'p':
case 'P':
if (strncmpiW(&argv[i][ci], progIDOpenW, 17) == 0)
progid_open = 1;
else {
WINE_ERR("Option '%s' not recognized\n", wine_dbgstr_w( argv[i]+ci-1));
usage();
}
break;
case 'w':
case 'W':
sei.fMask |= SEE_MASK_NOCLOSEPROCESS;
break;
default:
WINE_ERR("Option '%s' not recognized\n", wine_dbgstr_w( argv[i]+ci-1));
usage();
}
/* Skip to next slash */
while (argv[i][ci] && (argv[i][ci] != '/'))
ci++;
}
}
if (i == argc)
usage();
if (progid_open) {
sei.lpClass = argv[i++];
sei.fMask |= SEE_MASK_CLASSNAME;
}
sei.lpFile = argv[i++];
args = build_args( argc - i, &argv[i] );
sei.lpParameters = args;
if (unix_mode || progid_open) {
LPWSTR (*CDECL wine_get_dos_file_name_ptr)(LPCSTR);
char* multibyte_unixpath;
int multibyte_unixpath_len;
wine_get_dos_file_name_ptr = (void*)GetProcAddress(GetModuleHandleA("KERNEL32"), "wine_get_dos_file_name");
if (!wine_get_dos_file_name_ptr)
fatal_string(STRING_UNIXFAIL);
multibyte_unixpath_len = WideCharToMultiByte(CP_UNIXCP, 0, sei.lpFile, -1, NULL, 0, NULL, NULL);
multibyte_unixpath = HeapAlloc(GetProcessHeap(), 0, multibyte_unixpath_len);
WideCharToMultiByte(CP_UNIXCP, 0, sei.lpFile, -1, multibyte_unixpath, multibyte_unixpath_len, NULL, NULL);
dos_filename = wine_get_dos_file_name_ptr(multibyte_unixpath);
HeapFree(GetProcessHeap(), 0, multibyte_unixpath);
if (!dos_filename)
fatal_string(STRING_UNIXFAIL);
sei.lpFile = dos_filename;
sei.lpDirectory = parent_directory = get_parent_dir(dos_filename);
sei.fMask &= ~SEE_MASK_FLAG_NO_UI;
if (GetBinaryTypeW(sei.lpFile, &binary_type)) {
WCHAR *commandline;
STARTUPINFOW startup_info;
PROCESS_INFORMATION process_information;
static WCHAR commandlineformat[] = {'"','%','s','"','%','s',0};
/* explorer on windows always quotes the filename when running a binary on windows (see bug 5224) so we have to use CreateProcessW in this case */
commandline = HeapAlloc(GetProcessHeap(), 0, (strlenW(sei.lpFile)+3+strlenW(sei.lpParameters))*sizeof(WCHAR));
sprintfW(commandline, commandlineformat, sei.lpFile, sei.lpParameters);
ZeroMemory(&startup_info, sizeof(startup_info));
startup_info.cb = sizeof(startup_info);
if (!CreateProcessW(
NULL, /* lpApplicationName */
commandline, /* lpCommandLine */
NULL, /* lpProcessAttributes */
NULL, /* lpThreadAttributes */
FALSE, /* bInheritHandles */
CREATE_NEW_CONSOLE, /* dwCreationFlags */
NULL, /* lpEnvironment */
sei.lpDirectory, /* lpCurrentDirectory */
&startup_info, /* lpStartupInfo */
&process_information /* lpProcessInformation */ ))
{
fatal_string_error(STRING_EXECFAIL, GetLastError(), sei.lpFile);
}
sei.hProcess = process_information.hProcess;
goto done;
}
}
if (!ShellExecuteExW(&sei))
fatal_string_error(STRING_EXECFAIL, GetLastError(), sei.lpFile);
done:
HeapFree( GetProcessHeap(), 0, args );
HeapFree( GetProcessHeap(), 0, dos_filename );
HeapFree( GetProcessHeap(), 0, parent_directory );
if (sei.fMask & SEE_MASK_NOCLOSEPROCESS) {
DWORD exitcode;
WaitForSingleObject(sei.hProcess, INFINITE);
GetExitCodeProcess(sei.hProcess, &exitcode);
ExitProcess(exitcode);
}
ExitProcess(0);
}
string get_file_dir(const string& file_path)
{
return get_parent_dir(get_file_full_path(file_path));
}
