Example #1
0
/**
 * @internal
 * @brief get_boot_exec_list helper.
 */
NTSTATUS NTAPI query_routine(PWSTR ValueName,
  ULONG ValueType,PVOID ValueData,ULONG ValueLength,
  PVOID Context,PVOID EntryContext)
{
    struct cmd **list = (struct cmd **)Context;
    struct cmd *command, *prev_command = NULL;
    wchar_t *cmd;
    
    if(list == NULL){
        etrace("list is equal to NULL");
        return STATUS_UNSUCCESSFUL;
    }
    
    if(ValueType != REG_SZ){
        etrace("invalid %ws value type: 0x%x",
            ValueName, (UINT)ValueType);
        return STATUS_UNSUCCESSFUL;
    }

    cmd = winx_tmalloc(ValueLength + sizeof(wchar_t));
    if(cmd == NULL){
        mtrace();
        return STATUS_NO_MEMORY;
    }
    memset(cmd,0,ValueLength + sizeof(wchar_t));
    memcpy(cmd,ValueData,ValueLength);

    if(*list) prev_command = (*list)->prev;
    command = (struct cmd *)winx_list_insert(
        (list_entry **)(void *)list,
        (list_entry *)prev_command,
        sizeof(struct cmd));
    command->cmd = cmd;
    return STATUS_SUCCESS;
}
Example #2
0
/**
 * @brief Check whether the requested
 * action is allowed or not.
 * @return Zero indicates that the
 * requested operation is allowed,
 * negative value indicates contrary.
 */
static int check_requested_action(udefrag_job_parameters *jp)
{
    if(jp->job_type != ANALYSIS_JOB && jp->fs_type == FS_UDF){
        etrace("cannot defragment/optimize UDF volumes,");
        etrace("because the file system driver does not support FSCTL_MOVE_FILE");
        return UDEFRAG_UDF_DEFRAG;
    }

    if(jp->is_fat) itrace("FAT directories cannot be moved entirely");
    return 0;
}
Example #3
0
/**
 * @brief Creates a directory tree.
 * @param[in] path the native path.
 * @return Zero for success,
 * negative value otherwise.
 */
int winx_create_path(wchar_t *path)
{
    /*wchar_t rootdir[] = L"\\??\\X:\\";*/
    winx_volume_information v;
    wchar_t *p;
    size_t n;
    
    if(path == NULL)
        return (-1);

    /* path must contain at least \??\X: */
    if(wcsstr(path,L"\\??\\") != path || wcschr(path,':') != (path + 5)){
        etrace("native path must be specified");
        return (-1);
    }

    n = wcslen(L"\\??\\X:\\");
    if(wcslen(path) <= n){
        /* check for volume existence */
        /*
        rootdir[4] = path[4];
        // may fail with access denied status
        return winx_create_directory(rootdir);
        */
        return winx_get_volume_information((char)path[4],&v);
    }
    
    /* skip \??\X:\ */
    p = path + n;
    
    /* create directory tree */
    while((p = wcschr(p,'\\'))){
        *p = 0;
        if(winx_create_directory(path) < 0){
            *p = '\\';
            etrace("cannot create %ws",path);
            return (-1);
        }
        *p = '\\';
        p ++;
    }
    
    /* create target directory */
    if(winx_create_directory(path) < 0){
        etrace("cannot create %ws",path);
        return (-1);
    }
    
    return 0;
}
Example #4
0
/**
 * @brief Removes a file block from
 * the binary tree of all file blocks.
 * @return Zero for success, 
 * negative value otherwise.
 */
int remove_block_from_file_blocks_tree(udefrag_job_parameters *jp, winx_blockmap *block)
{
    struct file_block *fb;
    struct file_block b;
    
    if(block == NULL)
        return (-1);
    
    if(jp->file_blocks == NULL)
        return (-1);

    b.file = NULL;
    b.block = block;
    fb = prb_delete(jp->file_blocks,&b);
    if(fb == NULL){
        /* the following debugging output indicates either
           a bug, or file system inconsistency */
        etrace("failed for %p: VCN = %I64u, LCN = %I64u, LEN = %I64u",
            block, block->vcn, block->lcn, block->length);
        /* if block does not exist in tree, we have nothing to cleanup */
        return 0;
    }
    winx_free(fb);
    return 0;
}
Example #5
0
static wchar_t *get_report_path(udefrag_job_parameters *jp)
{
    wchar_t *instdir, *fpath;
    wchar_t *isportable;//genBTC
    wchar_t *path = NULL;

    isportable = winx_getenv(L"UD_IS_PORTABLE");//genBTC
    if(isportable != NULL){
        /* portable version? */
        fpath = winx_get_module_filename();
        if(fpath == NULL){
            etrace("cannot get program\'s path");
        } else {
            winx_path_remove_filename(fpath);
            path = winx_swprintf(L"\\??\\%ws\\reports",fpath);
            if(path == NULL){
                etrace("not enough memory (case 1)");
            } else {
                (void)winx_create_directory(path);
                winx_free(path);
            }
            path = winx_swprintf(L"\\??\\%ws\\reports\\fraglist_%c.luar",
                fpath,winx_tolower(jp->volume_letter));
            if(path == NULL)
                etrace("not enough memory (case 2)");
            winx_free(fpath);
        }
    } else {
        instdir = winx_getenv(L"UD_INSTALL_DIR");
        /* regular installation */
        path = winx_swprintf(L"\\??\\%ws\\reports",instdir);
        if(path == NULL){
            etrace("not enough memory (case 3)");
        } else {
            (void)winx_create_directory(path);
            winx_free(path);
        }
        path = winx_swprintf(L"\\??\\%ws\\reports\\fraglist_%c.luar",
            instdir,winx_tolower(jp->volume_letter));
        if(path == NULL)
            etrace("not enough memory (case 4)");
        winx_free(instdir);
    }
    return path;
}
Example #6
0
void MainFrame::SetSystemTrayIcon(const wxString& icon, const wxString& tooltip)
{
    if(CheckOption(wxT("UD_MINIMIZE_TO_SYSTEM_TRAY"))){
        wxIcon i = wxIcon(icon,wxBITMAP_TYPE_ICO_RESOURCE,g_iconSize,g_iconSize);
        if(!m_systemTrayIcon->SetIcon(i,tooltip)){
            etrace("system tray icon setup failed");
            wxSetEnv(wxT("UD_MINIMIZE_TO_SYSTEM_TRAY"),wxT("0"));
        }
    }
}
Example #7
0
void MainFrame::OnLangOpenFolder(wxCommandEvent& WXUNUSED(event))
{
    wxString AppPoDir(wxGetCwd() + wxT("/po"));

    if(!wxDirExists(AppPoDir)){
        etrace("po dir not found: %ls",AppPoDir.wc_str());
    } else {
        if(!wxLaunchDefaultBrowser(AppPoDir))
            Utils::ShowError(wxT("Cannot open %ls!"),AppPoDir.wc_str());
    }
}
Example #8
0
/**
 * @brief Retrieves the detailed information
 * about a disk volume.
 * @param[in] volume_letter the volume letter.
 * @param[in,out] v pointer to structure
 * receiving the volume information.
 * @return Zero for success, negative
 * value otherwise.
 */
int winx_get_volume_information(char volume_letter,winx_volume_information *v)
{
    HANDLE hRoot;
    
    /* check input data correctness */
    if(v == NULL)
        return (-1);

    /* ensure that it will work on w2k */
    volume_letter = winx_toupper(volume_letter);
    
    /* reset all fields of the structure, except of volume_letter */
    memset(v,0,sizeof(winx_volume_information));
    v->volume_letter = volume_letter;

    if(volume_letter < 'A' || volume_letter > 'Z')
        return (-1);
    
    /* open root directory */
    hRoot = OpenRootDirectory(volume_letter);
    if(hRoot == NULL)
        return (-1);
    
    /* get drive geometry */
    if(get_drive_geometry(hRoot,v) < 0){
        NtClose(hRoot);
        return (-1);
    }
    
    /* get the name of contained file system */
    if(get_filesystem_name(hRoot,v) < 0){
        NtClose(hRoot);
        return (-1);
    }
    
    /* get name of the volume */
    get_volume_label(hRoot,v);

    /* get NTFS data */
    memset(&v->ntfs_data,0,sizeof(NTFS_DATA));
    if(!strcmp(v->fs_name,"NTFS")){
        if(get_ntfs_data(v) < 0){
            etrace("NTFS data is unavailable for %c:",
                volume_letter);
        }
    }
    
    /* get dirty flag */
    get_volume_dirty_flag(v);
    
    NtClose(hRoot);
    return 0;
}
Example #9
0
BOOL CUIGlobals::InitColorsAndTablesAndObjects(LPDICOLORSET lpDIColorSet)
{tracescope(__ts,_T("CUIGlobals::InitColorsAndTablesAndObjects()\n"));

	// init ui tables
	if (!InitTables())
	{
		etrace(_T("Could not initialize tables\n"));
		return FALSE;
	}

	// decide whether or not to use the passed colorset
	if (lpDIColorSet != NULL)
	{
		m_ColorSet = *lpDIColorSet;

		m_bUseColorSet = !IsZeroOrInvalidColorSet(m_ColorSet);
	}
	else
		m_bUseColorSet = FALSE;

	// use it, or use defaults
	if (m_bUseColorSet)
	{
		// transfer colors from passed colorset
		SetTableColor(UIC_TEXTFORE, D3DCOLOR2COLORREF(m_ColorSet.cTextFore));
		SetTableColor(UIC_TEXTHIGHLIGHT, D3DCOLOR2COLORREF(m_ColorSet.cTextHighlight));
		SetTableColor(UIC_CALLOUTLINE, D3DCOLOR2COLORREF(m_ColorSet.cCalloutLine));
		SetTableColor(UIC_CALLOUTHIGHLIGHT, D3DCOLOR2COLORREF(m_ColorSet.cCalloutHighlight));
		SetTableColor(UIC_BORDER, D3DCOLOR2COLORREF(m_ColorSet.cBorder));
		SetTableColor(UIC_CONTROLFILL, D3DCOLOR2COLORREF(m_ColorSet.cControlFill));
		SetTableColor(UIC_HIGHLIGHTFILL, D3DCOLOR2COLORREF(m_ColorSet.cHighlightFill));
		SetTableColor(UIC_AREAFILL, D3DCOLOR2COLORREF(m_ColorSet.cAreaFill));
	}
	else
	{
		// use default colors
		SetTableColor(UIC_TEXTFORE,				RGB(255, 255, 255));
		SetTableColor(UIC_TEXTHIGHLIGHT,		RGB(  0, 255,   0));
		SetTableColor(UIC_CALLOUTLINE,			RGB(255, 255, 255));
		SetTableColor(UIC_CALLOUTHIGHLIGHT,		RGB(  0, 255,   0));
		SetTableColor(UIC_BORDER,				RGB(255, 255,   0));
		SetTableColor(UIC_CONTROLFILL,			RGB(  0, 191,   0));
		SetTableColor(UIC_HIGHLIGHTFILL,		RGB(  0,   0,   0));
		SetTableColor(UIC_AREAFILL,				RGB(  0,   0,   0));
	}

	// create the table objects
	CreateObjects();

	return TRUE;
}
Example #10
0
/**
 * @brief Retrieves free space layout.
 * @return Zero for success, negative value otherwise.
 */
static int get_free_space_layout(udefrag_job_parameters *jp)
{
    char buffer[32];

    jp->free_regions = winx_get_free_volume_regions(jp->volume_letter,
        WINX_GVR_ALLOW_PARTIAL_SCAN,process_free_region,(void *)jp);
    
    winx_bytes_to_hr(jp->v_info.free_bytes,2,buffer,sizeof(buffer));
    itrace("free space amount : %s",buffer);
    itrace("free regions count: %u",jp->free_regions_count);
    
    /* let full disks to pass the analysis successfully */
    if(jp->free_regions == NULL || jp->free_regions_count == 0)
        etrace("disk is full or some error has been encountered");
    return 0;
}
Example #11
0
HRESULT CDeviceUI::Init(const DIDEVICEINSTANCEW &didi, LPDIRECTINPUTDEVICE8W lpDID, HWND hWnd, CDeviceUINotify *pNotify)
{tracescope(__ts, _T("CDeviceUI::Init()...\n"));
	// save the params
	m_priv_didi = didi;
	m_priv_lpDID = lpDID;
	m_pNotify = pNotify;
	m_hWnd = hWnd;

	// fail if we don't have lpDID
	if (m_lpDID == NULL)
	{
		etrace(_T("CDeviceUI::Init() was passed a NULL lpDID!\n"));
		return E_FAIL;
	}

	// fill the devobjstruct
	HRESULT hr = FillDIDeviceObjectStruct(m_priv_os, lpDID);
	if (FAILED(hr))
	{
		etrace1(_T("FillDIDeviceObjectStruct() failed, returning 0x%08x\n"), hr);
		return hr;
	}

	// view rect needs to be set before populating so the views are
	// created with the correct dimensions
	m_ViewRect = g_ViewRect;

	// populate
	hr = PopulateAppropriately(*this);
	if (FAILED(hr))
		return hr;

	// if there are no views, return
	if (GetNumViews() < 1)
	{
		Unpopulate();
		return E_FAIL;
	}

	// show the first view
	SetView(0);

	return hr;
}
Example #12
0
//better off with a struct to pass any variables we need IN. Such as:
// drive_letter. query_type. File Path.  (combine/variables set above)
void *QueryThread::Entry()
{
    int result;

    while(!g_mainFrame->CheckForTermination(200)){
        if(m_startquery){
            result = udefrag_start_query(m_letter,m_qType,m_flags,m_mapSize,
                reinterpret_cast<udefrag_progress_callback>(ProgressCallback),
                reinterpret_cast<udefrag_terminator>(Terminator),m_qp,NULL
            );
            if(result < 0 && !g_mainFrame->m_stopped){
                etrace("Disk Processing Failure.");
                g_mainFrame->WxTextCtrl1->AppendText(L"Error executing Query.");
            }
            PostCommandEvent(g_mainFrame,ID_QueryCompletion);
            m_startquery = false;
        }
    }
    return NULL;
}
Example #13
0
/**
 * @brief Adds file to the list of fragmented files.
 * @note Ignores files excluded from the disk processing.
 */
int expand_fragmented_files_list(winx_file_info *f,udefrag_job_parameters *jp)
{
    void **p;
    
    /* don't include filtered out files, for better performance */
    //genBTC asks:
    // Wouldnt this already be filtered out, since this is only called from:
    // Analyze.C, produce_list_of_fragmented_files()
    //   and
    // Move.C, move_file() near the very end
    // and in both functions, they are called from inside this if block:
    //         if(is_fragmented(f) && !is_excluded(f)){
    // so they should already be verified by !is_exluded(f)
    //I guess this was put in for future expansion?

    //if(!is_excluded(f)){
        p = prb_probe(jp->fragmented_files,(void *)f);
        if(*p != f) etrace("a duplicate found for %ws",f->path);
    //}
    return 0;
}
Example #14
0
/**
 * @internal
 * @brief Retrieves the volume dirty flag.
 * @param[out] pointer to the structure
 * receiving the volume dirty flag.
 */
static void get_volume_dirty_flag(winx_volume_information *v)
{
    WINX_FILE *f;
    ULONG dirty_flag;
    int result;
    
    /* open the volume */
    f = winx_vopen(v->volume_letter);
    if(f == NULL) return;
    
    /* get dirty flag */
    result = winx_ioctl(f,FSCTL_IS_VOLUME_DIRTY,
        "get_volume_dirty_flag: dirty flag request",
        NULL,0,&dirty_flag,sizeof(ULONG),NULL);
    winx_fclose(f);
    if(result >= 0 && (dirty_flag & VOLUME_IS_DIRTY)){
        etrace("%c: volume is dirty! Run CHKDSK to repair it.",
            v->volume_letter);
        v->is_dirty = 1;
    }
}
Example #15
0
/**
 * @brief Adds a file block to
 * the binary tree of all file blocks.
 * @return Zero for success, 
 * negative value otherwise.
 * @note Destroys the tree in case of errors.
 */
int add_block_to_file_blocks_tree(udefrag_job_parameters *jp, winx_file_info *file, winx_blockmap *block)
{
    struct file_block *fb;
    void **p;
    
    if(file == NULL || block == NULL)
        return (-1);
    
    if(jp->file_blocks == NULL)
        return (-1);

    fb = winx_malloc(sizeof *fb);
    fb->file = file;
    fb->block = block;
    p = prb_probe(jp->file_blocks,(void *)fb);
    /* if a duplicate item exists... */
    if(*p != fb){
        etrace("a duplicate found");
        winx_free(fb);
    }
    return 0;
}
Example #16
0
/**
 * @brief Searches for the first movable file block
 * after the specified cluster on the volume.
 * @param[in] jp job parameters.
 * @param[in,out] min_lcn pointer to variable containing
 * minimum LCN - file blocks below it will be ignored.
 * @param[in] flags one of SKIP_xxx flags defined in udefrag.h
 * @param[out] first_file pointer to variable receiving information
 * about the file the first block belongs to.
 * @return Pointer to the first block. NULL indicates failure.
 */
winx_blockmap *find_first_block(udefrag_job_parameters *jp,
    ULONGLONG *min_lcn, int flags, winx_file_info **first_file)
{
    winx_file_info *found_file;
    winx_blockmap *first_block;
    winx_blockmap b;
    struct file_block fb, *item;
    struct prb_traverser t;
    int movable_file;
    ULONGLONG tm = winx_xtime();
    
    if(min_lcn == NULL || first_file == NULL)
        return NULL;
    
    found_file = NULL; first_block = NULL;
    b.lcn = *min_lcn; fb.block = &b;
    prb_t_init(&t,jp->file_blocks);
    item = prb_t_insert(&t,jp->file_blocks,&fb);
    if(item == &fb){
        /* block at min_lcn not found */
        item = prb_t_next(&t);
        if(prb_delete(jp->file_blocks,&fb) == NULL){
            etrace("cannot remove block from the tree");
            winx_flush_dbg_log(0); /* 'cause error is critical */
        }
    }
    if(item){
        found_file = item->file;
        first_block = item->block;
    }
    while(!jp->termination_router((void *)jp)){
        if(found_file == NULL) break;
        if(flags & SKIP_PARTIALLY_MOVABLE_FILES){
            movable_file = can_move_entirely(found_file,jp);
        } else {
            movable_file = can_move(found_file,jp);
        }
        if(is_file_locked(found_file,jp)) movable_file = 0;
        if(movable_file){
            if(jp->is_fat && is_directory(found_file) && first_block == found_file->disp.blockmap){
                /* skip first fragments of FAT directories */
            } else {
                /* desired block found */
                *min_lcn = first_block->lcn + 1; /* the current block will be skipped later anyway in this case */
                *first_file = found_file;
                jp->p_counters.searching_time += winx_xtime() - tm;
                return first_block;
            }
        }
        
        /* skip current block */
        *min_lcn = *min_lcn + 1;
        /* and go to the next one */
        item = prb_t_next(&t);
        if(item == NULL) break;
        found_file = item->file;
        first_block = item->block;
    }
    *first_file = NULL;
    jp->p_counters.searching_time += winx_xtime() - tm;
    return NULL;
}
Example #17
0
/**
 * @brief Initializes main window.
 */
MainFrame::MainFrame()
    :wxFrame(NULL,wxID_ANY,wxT("UltraDefrag"))
{
    g_mainFrame = this;
    m_vList = NULL;
    m_cMap = NULL;
    m_currentJob = NULL;
    m_busy = false;
    m_paused = false;

    // set main window icon
    SetIcons(wxICON(appicon));

    // read configuration
    ReadAppConfiguration();
    ProcessCommandEvent(ID_ReadUserPreferences);

    // set main window title
    wxString *instdir = new wxString();
    //genBTC re-arranged the below, A LOT.
    wxStandardPaths stdpaths;
    wxFileName exepath(stdpaths.GetExecutablePath());
    wxString cd = exepath.GetPath();
    if((wxGetEnv(wxT("UD_INSTALL_DIR"),instdir))&&(cd.CmpNoCase(*instdir) == 0)) {
        itrace("current directory matches installation location, so it isn't portable");
        itrace("installation location: %ls",instdir->wc_str());
        m_title = new wxString(wxT(VERSIONINTITLE));
    } else {
        itrace("current directory differs from installation location, so it is portable");
        itrace("current directory: %ls",cd.wc_str());
        wxSetEnv(wxT("UD_IS_PORTABLE"),wxT("1"));
        m_title = new wxString(wxT(VERSIONINTITLE_PORTABLE));
    }
    //genBTC re-arranged the above, A LOT.
    ProcessCommandEvent(ID_SetWindowTitle);
    delete instdir;

    // set main window size and position
    SetSize(m_width,m_height);
    if(!m_saved){
        CenterOnScreen();
        GetPosition(&m_x,&m_y);
    }
    Move(m_x,m_y);
    if(m_maximized) Maximize(true);

    SetMinSize(wxSize(DPI(MAIN_WINDOW_MIN_WIDTH),DPI(MAIN_WINDOW_MIN_HEIGHT)));

    // create menu, tool and status bars
    InitMenu(); InitToolbar(); InitStatusBar();

	//make sizer1 to hold the the tabbed "notebook". And make the notebook
	wxBoxSizer* bSizer1;
	bSizer1 = new wxBoxSizer( wxVERTICAL );
	m_notebook1 = new wxNotebook( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 );

	//make a panel inside the notebook to hold the m_splitter
	m_panel1 = new wxPanel( m_notebook1, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

    // create list of volumes and cluster map (with splitter as parent)
    m_splitter = new wxSplitterWindow(m_panel1,wxID_ANY, wxDefaultPosition,wxDefaultSize, 
                                      wxSP_3D | wxCLIP_CHILDREN);
    m_splitter->SetMinimumPaneSize(DPI(MIN_PANEL_HEIGHT));

    m_vList = new DrivesList(m_splitter,wxLC_REPORT | wxLC_NO_SORT_HEADER | 
                             wxLC_HRULES | wxLC_VRULES | wxBORDER_NONE);

    m_cMap = new ClusterMap(m_splitter);

    m_splitter->SplitHorizontally(m_vList,m_cMap);

    int height = GetClientSize().GetHeight();
    int maxPanelHeight = height - DPI(MIN_PANEL_HEIGHT) - m_splitter->GetSashSize();
    if(m_separatorPosition < DPI(MIN_PANEL_HEIGHT)) m_separatorPosition = DPI(MIN_PANEL_HEIGHT);
    else if(m_separatorPosition > maxPanelHeight) m_separatorPosition = maxPanelHeight;
    m_splitter->SetSashPosition(m_separatorPosition);

    // update frame layout so we'll be able to initialize
    // list of volumes and cluster map properly
    wxSizeEvent evt(wxSize(m_width,m_height));
    ProcessEvent(evt); m_splitter->UpdateSize();

    InitVolList();
    m_vList->SetFocus();

    // populate list of volumes
    m_listThread = new ListThread();

    //make sizer2 to Fit the splitter, and initialize it.
	wxBoxSizer* bSizer2;
	bSizer2 = new wxBoxSizer( wxVERTICAL );
	bSizer2->Add( m_splitter, 1, wxEXPAND, 1 );
	m_panel1->SetSizer( bSizer2 );

	//Finish Tab1 - Add the Panel1(Splitter+sizer2) to the notebook.
	m_notebook1->AddPage( m_panel1, wxT("Drives"), false );

	//make a 2nd panel inside the notebook to hold the 2nd page(a grid)
	m_panel2 = new wxPanel( m_notebook1, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

    m_filesList = new FilesList(m_panel2,wxLC_REPORT /* | wxLC_SINGLE_SEL  | wxLC_NO_SORT_HEADER*/ \
                                        | wxLC_VIRTUAL | wxLC_HRULES | wxLC_VRULES | wxBORDER_NONE);
    InitFilesList();

	//make sizer3 to Fit the page2list, and initialize it.
	wxBoxSizer* bSizer3;
	bSizer3 = new wxBoxSizer( wxVERTICAL );
	bSizer3->Add( m_filesList, 1, wxEXPAND, 1 );
	m_panel2->SetSizer( bSizer3 );
    bSizer3->Fit( m_panel2 );

	//Finish Tab 2 - Add the Panel2(page2list+sizer3) to the notebook.
	m_notebook1->AddPage( m_panel2, wxT("Files"), false );

    //Finish Notebook & initialize
	bSizer1->Add( m_notebook1, 1, wxEXPAND, 1 );
	this->SetSizer( bSizer1 );

    // check the boot time defragmenter presence
    wxFileName btdFile(wxT("%SystemRoot%\\system32\\defrag_native.exe"));
    btdFile.Normalize();
    bool btd = btdFile.FileExists();
    m_menuBar->FindItem(ID_BootEnable)->Enable(btd);
    m_menuBar->FindItem(ID_BootScript)->Enable(btd);
    m_toolBar->EnableTool(ID_BootEnable,btd);
    m_toolBar->EnableTool(ID_BootScript,btd);
    if(btd && ::winx_bootex_check(L"defrag_native") > 0){
        m_menuBar->FindItem(ID_BootEnable)->Check(true);
        m_toolBar->ToggleTool(ID_BootEnable,true);
        m_btdEnabled = true;
    } else {
        m_btdEnabled = false;
    }

    // launch threads for time consuming operations
    m_btdThread = btd ? new BtdThread() : NULL;
    m_configThread = new ConfigThread();
    m_crashInfoThread = new CrashInfoThread();

    wxConfigBase *cfg = wxConfigBase::Get();
    int ulevel = (int)cfg->Read(wxT("/Upgrade/Level"),1);
    wxMenuItem *item = m_menuBar->FindItem(ID_HelpUpgradeNone + ulevel);
    if(item) item->Check();

    m_upgradeThread = new UpgradeThread(ulevel);

    // set system tray icon
    m_systemTrayIcon = new SystemTrayIcon();
    if(!m_systemTrayIcon->IsOk()){
        etrace("system tray icon initialization failed");
        wxSetEnv(wxT("UD_MINIMIZE_TO_SYSTEM_TRAY"),wxT("0"));
    }
    SetSystemTrayIcon(wxT("tray"),wxT("UltraDefrag"));

    // set localized text
    ProcessCommandEvent(ID_LocaleChange + g_locale->GetLanguage());

    // allow disk processing
    m_jobThread = new JobThread();

    //create query thread to perform queries without blocking the GUI
    //(sort of like jobs) - may not be good to have both possibly running at once.
    //Create Query Tab, Tab #3.
    InitQueryMenu();
    
    UD_DisableTool(ID_Stop);    //change stop icon to be not always enabled.
}
Example #18
0
/**
 * @brief A Win32 GetDriveType() native equivalent.
 * @param[in] letter the volume letter
 * @return The drive type, negative value indicates failure.
 */
int winx_get_drive_type(char letter)
{
    wchar_t link_name[] = L"\\??\\A:";
    #define MAX_TARGET_LENGTH 256
    wchar_t link_target[MAX_TARGET_LENGTH];
    PROCESS_DEVICEMAP_INFORMATION pdi;
    FILE_FS_DEVICE_INFORMATION ffdi;
    IO_STATUS_BLOCK iosb;
    NTSTATUS status;
    int drive_type;
    HANDLE hRoot;

    /* The additional checks for DFS were suggested by Stefan Pendl ([email protected]). */
    /* DFS shares have DRIVE_NO_ROOT_DIR type though they are actually remote. */

    letter = winx_toupper(letter);
    if(letter < 'A' || letter > 'Z'){
        etrace("invalid letter %c",letter);
        return (-1);
    }
    
    /* check for the drive existence */
    link_name[4] = (wchar_t)letter;
    if(winx_query_symbolic_link(link_name,link_target,MAX_TARGET_LENGTH) < 0)
        return (-1);
    
    /* check for an assignment made by subst command */
    if(wcsstr(link_target,L"\\??\\") == (wchar_t *)link_target)
        return DRIVE_ASSIGNED_BY_SUBST_COMMAND;

    /* check for classical floppies */
    if(wcsstr(link_target,L"Floppy"))
        return DRIVE_REMOVABLE;
    
    /* try to define exactly which type has the specified drive */
    RtlZeroMemory(&pdi,sizeof(PROCESS_DEVICEMAP_INFORMATION));
    status = NtQueryInformationProcess(NtCurrentProcess(),
                    ProcessDeviceMap,&pdi,
                    sizeof(PROCESS_DEVICEMAP_INFORMATION),
                    NULL);
    if(NT_SUCCESS(status)){
        drive_type = (int)pdi.Query.DriveType[letter - 'A'];
        /*
        * Type DRIVE_NO_ROOT_DIR have the following drives:
        * 1. assigned by subst command
        * 2. SCSI external drives
        * 3. RAID volumes
        * 4. DFS shares
        * We need additional checks to know exactly.
        */
        if(drive_type != DRIVE_NO_ROOT_DIR)
            return drive_type;
    } else {
        strace(status,"cannot get device map");
        return (-1);
    }
    
    /* try to define exactly again which type has the specified drive */
    /* note that the drive motor can be powered on during this check */
    hRoot = OpenRootDirectory(letter);
    if(hRoot == NULL)
        return (-1);
    RtlZeroMemory(&ffdi,sizeof(FILE_FS_DEVICE_INFORMATION));
    status = NtQueryVolumeInformationFile(hRoot,&iosb,
                    &ffdi,sizeof(FILE_FS_DEVICE_INFORMATION),
                    FileFsDeviceInformation);
    NtClose(hRoot);
    if(!NT_SUCCESS(status)){
        strace(status,"cannot get volume type for \'%c\'",letter);
        return (-1);
    }

    /* detect remote/cd/dvd/unknown drives */
    if(ffdi.Characteristics & FILE_REMOTE_DEVICE)
        return DRIVE_REMOTE;
    switch(ffdi.DeviceType){
    case FILE_DEVICE_CD_ROM:
    case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
    case FILE_DEVICE_DVD:
        return DRIVE_CDROM;
    case FILE_DEVICE_NETWORK_FILE_SYSTEM:
    case FILE_DEVICE_NETWORK: /* ? */
    case FILE_DEVICE_NETWORK_BROWSER: /* ? */
    case FILE_DEVICE_DFS_FILE_SYSTEM:
    case FILE_DEVICE_DFS_VOLUME:
    case FILE_DEVICE_DFS:
        return DRIVE_REMOTE;
    case FILE_DEVICE_UNKNOWN:
        return DRIVE_UNKNOWN;
    }

    /* detect removable disks */
    if(ffdi.Characteristics & FILE_REMOVABLE_MEDIA)
        return DRIVE_REMOVABLE;

    /* detect fixed disks */
    switch(ffdi.DeviceType){
    case FILE_DEVICE_DISK:
    case FILE_DEVICE_FILE_SYSTEM: /* ? */
    /*case FILE_DEVICE_VIRTUAL_DISK:*/
    /*case FILE_DEVICE_MASS_STORAGE:*/
    case FILE_DEVICE_DISK_FILE_SYSTEM:
        return DRIVE_FIXED;
    default:
        break;
    }
    
    /* nothing detected => drive type is unknown */
    return DRIVE_UNKNOWN;
}
Example #19
0
HRESULT CUIGlobals::Init(UIG_PARAMS_DEFINE)
{tracescope(__ts,_T("CUIGlobals::Init(...)\n"));

	HRESULT hr = S_OK;

	// get instance handle
	m_hInst = (HINSTANCE)g_hModule;
	if (m_hInst == NULL)
	{
		etrace(_T("hInst NULL\n"));
		return E_FAIL;
	}

	// create direct input
	DWORD dwVer = DIRECTINPUT_VERSION;
	hr = DirectInput8Create(m_hInst, dwVer, IID_IDirectInput8W, (LPVOID *)&m_lpDI, NULL);
	if (FAILED(hr) || m_lpDI == NULL)
	{
		m_lpDI = NULL;
		etrace2(_T("Could not create DirectInput ver 0x%08x\n  -> DirectInputCreateEx() returned 0x%08x\n"), dwVer, hr);
		return hr;
	}

	// save flags
	m_dwFlags = dwFlags;
#ifdef CFGUI__FORCE_NON_NULL_WSZUSERNAMES
	if (wszUserNames == NULL)
		wszUserNames = _T("Forced Non-NULL Username");
#endif
	if (wszUserNames == NULL)
	{
		etrace(_T("wszUserNames was passed NULL\n"));
		return E_FAIL;
	}

	// save user names
	m_wszUserNames = DupSuperString(wszUserNames);
	if (m_wszUserNames == NULL)
	{
		etrace(_T("Could not duplicate user names\n"));
		return E_FAIL;
	}

	// make sure we were passed an action format
	if (lpAcFor == NULL)
	{
		etrace(_T("lpAcFor param NULL\n"));
		return E_INVALIDARG;
	}

	// copy the acfor to the master
	hr = InitMasterAcForArray(lpAcFor, int(dwNumAcFor));
	if (FAILED(hr))
	{
		etrace1(_T("InitMasterAcForArray() failed, returning 0x%08x\n"), hr);
		return hr;
	}

	// get surface
	if (lpSurface != NULL)
	{
		hr = lpSurface->QueryInterface(IID_IDirect3DSurface8, (void **)&m_pSurface3D);
		if (FAILED(hr) || m_pSurface3D == NULL)
		{
			m_pSurface3D = NULL;
		}

		hr = lpSurface->QueryInterface(IID_IDirectDrawSurface, (void **)&m_pSurface);
		if (FAILED(hr) || m_pSurface == NULL)
		{
			m_pSurface = NULL;
		}

		if (m_pSurface == NULL && m_pSurface3D == NULL)
			etrace(_T("lpSurface was non-NULL but could not get IDirect3DSurface8 or IID_IDirectDrawSurface from it"));
	}

	// save callback and ref data
	m_lpCallback = lpCallback;
	m_pvRefData = pvRefData;

	// see whether or not we're allowing edit layout mode
	m_bAllowEditLayout = IsEqualGUID(RefMasterAcFor(0).guidActionMap,
		GUID_DIConfigAppEditLayout);

	// init a bunch of stuff necessary for painting
	if (!InitColorsAndTablesAndObjects(lpDIColorSet))
		return E_FAIL;

	// dump info if debug
#ifdef DBG
	Dump();
#endif

	// return success if we got here
	return S_OK;
}
Example #20
0
/**
 * @brief Removes file from the list of fragmented files.
 */
void truncate_fragmented_files_list(winx_file_info *f,udefrag_job_parameters *jp)
{
    if(!prb_delete(jp->fragmented_files,(void *)f))
        etrace("%ws is not found in the tree",f->path);
}
Example #21
0
/**
 * @brief Retrieves all information about the volume.
 * @return Zero for success, negative value otherwise.
 * @note Resets statistics and cluster map.
 */
int get_volume_information(udefrag_job_parameters *jp)
{
    char fs_name[MAX_FS_NAME_LENGTH + 1];
    int i;
    
    /* reset mft zone disposition */
    memset(&jp->mft_zone,0,sizeof(struct _mft_zone));

    /* reset v_info structure */
    memset(&jp->v_info,0,sizeof(winx_volume_information));
    
    /* reset statistics */
    jp->pi.files = 0;
    jp->pi.directories = 0;
    jp->pi.compressed = 0;
    jp->pi.fragmented = 0;
    jp->pi.fragments = 0;
    jp->pi.total_space = 0;
    jp->pi.free_space = 0;
    jp->pi.mft_size = 0;
    jp->pi.clusters_to_process = 0;
    jp->pi.processed_clusters = 0;
    
    jp->fs_type = FS_UNKNOWN;
    jp->is_fat = 0;
    
    /* reset file lists */
    destroy_lists(jp);
    
    /* update global variables holding drive geometry */
    if(winx_get_volume_information(jp->volume_letter,&jp->v_info) < 0)
        return (-1);
    
    /* don't touch dirty volumes */
    if(jp->v_info.is_dirty)
        return UDEFRAG_DIRTY_VOLUME;

    jp->pi.total_space = jp->v_info.total_bytes;
    jp->pi.free_space = jp->v_info.free_bytes;
    itrace("total clusters: %I64u",jp->v_info.total_clusters);
    jp->pi.used_clusters = jp->v_info.total_clusters - (jp->v_info.free_bytes / jp->v_info.bytes_per_cluster);
    itrace("used clusters : %I64u",jp->pi.used_clusters);
    itrace("cluster size: %I64u",jp->v_info.bytes_per_cluster);
    /* validate geometry */
    if(!jp->v_info.total_clusters || !jp->v_info.bytes_per_cluster){
        etrace("wrong volume geometry detected");
        return (-1);
    }
    adjust_move_at_once_parameter(jp);
    /* check partition type */
    itrace("%s partition detected",jp->v_info.fs_name);
    strncpy(fs_name,jp->v_info.fs_name,MAX_FS_NAME_LENGTH);
    fs_name[MAX_FS_NAME_LENGTH] = 0;
    _strupr(fs_name);
    for(i = 0; fs_types[i].name; i++){
        if(!strcmp(fs_name,fs_types[i].name)){
            jp->fs_type = fs_types[i].type;
            jp->is_fat = fs_types[i].is_fat;
            break;
        }
    }
    if(jp->fs_type == FS_UNKNOWN){
        etrace("file system type is not recognized");
        etrace("type independent routines will be used to defragment it");
    }
    
    jp->pi.clusters_to_process = jp->v_info.total_clusters;
    jp->pi.processed_clusters = 0;
    
    if(jp->udo.fragment_size_threshold){
        if(jp->udo.fragment_size_threshold <= jp->v_info.bytes_per_cluster){
            itrace("fragment size threshold is below the cluster size, so it will be ignored");
            jp->udo.fragment_size_threshold = 0;
        }
    }

    /* reset cluster map */
    reset_cluster_map(jp);
    return 0;
}