BtrfsDeviceAdd Class Reference

#include <devices.h>

Collaboration diagram for BtrfsDeviceAdd:

Public Member Functions
INT_PTR CALLBACK	DeviceAddDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	ShowDialog ()
void	AddDevice (HWND hwndDlg)
	BtrfsDeviceAdd (HINSTANCE hinst, HWND hwnd, WCHAR *cmdline)

Private Member Functions
void	populate_device_tree (HWND tree)

Private Attributes
HINSTANCE	hinst
HWND	hwnd
WCHAR *	cmdline
device *	sel
vector< device >	device_list

Detailed Description

Definition at line 139 of file devices.h.

Constructor & Destructor Documentation

BtrfsDeviceAdd()

BtrfsDeviceAdd::BtrfsDeviceAdd	(	HINSTANCE	hinst,
		HWND	hwnd,
		WCHAR *	cmdline
	)

Definition at line 677 of file devices.cpp.

                                                                         {
    this->hinst = hinst;
    this->hwnd = hwnd;
    this->cmdline = cmdline;

    sel = nullptr;
}

Member Function Documentation

AddDevice()

void BtrfsDeviceAdd::AddDevice

(

HWND

hwndDlg

)

Definition at line 525 of file devices.cpp.

                                           {
    wstring mess, title;
    NTSTATUS Status;
    UNICODE_STRING vn;
    OBJECT_ATTRIBUTES attr;
    IO_STATUS_BLOCK iosb;

    if (!sel) {
        EndDialog(hwndDlg, 0);
        return;
    }

    if (sel->fstype != L"") {
        wstring s;

        if (!load_string(module, IDS_ADD_DEVICE_CONFIRMATION_FS, s))
            throw last_error(GetLastError());

        wstring_sprintf(mess, s, sel->fstype.c_str());
    } else {
        if (!load_string(module, IDS_ADD_DEVICE_CONFIRMATION, mess))
            throw last_error(GetLastError());
    }

    if (!load_string(module, IDS_CONFIRMATION_TITLE, title))
        throw last_error(GetLastError());

    if (MessageBoxW(hwndDlg, mess.c_str(), title.c_str(), MB_YESNO) != IDYES)
        return;

    win_handle h = CreateFileW(cmdline, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                               OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);

    if (h == INVALID_HANDLE_VALUE)
        throw last_error(GetLastError());

    {
        nt_handle h2;

        vn.Length = vn.MaximumLength = (uint16_t)(sel->pnp_name.length() * sizeof(WCHAR));
        vn.Buffer = (WCHAR*)sel->pnp_name.c_str();

        InitializeObjectAttributes(&attr, &vn, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, nullptr, nullptr);

        Status = NtOpenFile(&h2, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);
        if (!NT_SUCCESS(Status))
            throw ntstatus_error(Status);

        if (!sel->is_disk) {
            Status = NtFsControlFile(h2, nullptr, nullptr, nullptr, &iosb, FSCTL_LOCK_VOLUME, nullptr, 0, nullptr, 0);
            if (!NT_SUCCESS(Status))
                throw string_error(IDS_LOCK_FAILED, Status);
        }

        Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_ADD_DEVICE, &h2, sizeof(HANDLE), nullptr, 0);
        if (!NT_SUCCESS(Status))
            throw ntstatus_error(Status);

        if (!sel->is_disk) {
            Status = NtFsControlFile(h2, nullptr, nullptr, nullptr, &iosb, FSCTL_DISMOUNT_VOLUME, nullptr, 0, nullptr, 0);
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);

            Status = NtFsControlFile(h2, nullptr, nullptr, nullptr, &iosb, FSCTL_UNLOCK_VOLUME, nullptr, 0, nullptr, 0);
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);
        }
    }

    EndDialog(hwndDlg, 0);
}

Referenced by DeviceAddDlgProc().

DeviceAddDlgProc()

INT_PTR CALLBACK BtrfsDeviceAdd::DeviceAddDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 597 of file devices.cpp.

                                                                                                       {
    try {
        switch (uMsg) {
            case WM_INITDIALOG:
            {
                EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
                populate_device_tree(GetDlgItem(hwndDlg, IDC_DEVICE_TREE));
                EnableWindow(GetDlgItem(hwndDlg, IDOK), false);
                break;
            }

            case WM_COMMAND:
                switch (HIWORD(wParam)) {
                    case BN_CLICKED:
                        switch (LOWORD(wParam)) {
                            case IDOK:
                                AddDevice(hwndDlg);
                            return true;

                            case IDCANCEL:
                                EndDialog(hwndDlg, 0);
                            return true;
                        }
                    break;
                }
            break;

            case WM_NOTIFY:
                switch (((LPNMHDR)lParam)->code) {
                    case TVN_SELCHANGEDW:
                    {
                        NMTREEVIEWW* nmtv = (NMTREEVIEWW*)lParam;
                        TVITEMW tvi;
                        bool enable = false;

                        RtlZeroMemory(&tvi, sizeof(TVITEMW));
                        tvi.hItem = nmtv->itemNew.hItem;
                        tvi.mask = TVIF_PARAM | TVIF_HANDLE;

                        if (SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_TREE), TVM_GETITEMW, 0, (LPARAM)&tvi))
                            sel = tvi.lParam == 0 ? nullptr : (device*)tvi.lParam;
                        else
                            sel = nullptr;

                        if (sel)
                            enable = (!sel->is_disk || !sel->has_parts) && !sel->multi_device;

                        EnableWindow(GetDlgItem(hwndDlg, IDOK), enable);
                        break;
                    }
                }
            break;
        }
    } catch (const exception& e) {
        error_message(hwndDlg, e.what());
    }

    return false;
}

Referenced by stub_DeviceAddDlgProc().

populate_device_tree()

void BtrfsDeviceAdd::populate_device_tree ( HWND  tree )

private

Definition at line 351 of file devices.cpp.

                                                   {
    HWND hwnd = GetParent(tree);
    unsigned int i;
    ULONG last_disk_num = 0xffffffff;
    HTREEITEM diskitem;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING us;
    IO_STATUS_BLOCK iosb;
    btrfs_filesystem* bfs = nullptr;

    static WCHAR btrfs[] = L"\\Btrfs";

    device_list.clear();

    {
        nt_handle mountmgr;

        RtlInitUnicodeString(&us, MOUNTMGR_DEVICE_NAME);
        InitializeObjectAttributes(&attr, &us, 0, nullptr, nullptr);

        Status = NtOpenFile(&mountmgr, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb,
                            FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT);

        if (!NT_SUCCESS(Status))
            throw string_error(IDS_CANT_OPEN_MOUNTMGR);

        {
            nt_handle btrfsh;

            us.Length = us.MaximumLength = (uint16_t)(wcslen(btrfs) * sizeof(WCHAR));
            us.Buffer = btrfs;

            InitializeObjectAttributes(&attr, &us, 0, nullptr, nullptr);

            Status = NtOpenFile(&btrfsh, SYNCHRONIZE | FILE_READ_ATTRIBUTES, &attr, &iosb,
                                FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_ALERT);
            if (NT_SUCCESS(Status)) {
                ULONG bfssize = 0;

                do {
                    bfssize += 1024;

                    if (bfs) free(bfs);
                    bfs = (btrfs_filesystem*)malloc(bfssize);

                    Status = NtDeviceIoControlFile(btrfsh, nullptr, nullptr, nullptr, &iosb, IOCTL_BTRFS_QUERY_FILESYSTEMS, nullptr, 0, bfs, bfssize);
                    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
                        free(bfs);
                        bfs = nullptr;
                        break;
                    }
                } while (Status == STATUS_BUFFER_OVERFLOW);

                if (bfs && bfs->num_devices == 0) { // no mounted filesystems found
                    free(bfs);
                    bfs = nullptr;
                }
            }
        }

        find_devices(hwnd, &GUID_DEVINTERFACE_DISK, mountmgr, device_list);
        find_devices(hwnd, &GUID_DEVINTERFACE_VOLUME, mountmgr, device_list);
        find_devices(hwnd, &GUID_DEVINTERFACE_HIDDEN_VOLUME, mountmgr, device_list);
    }

#ifndef __REACTOS__ // Disabled because building with our <algorithm> seems complex right now...
    sort(device_list.begin(), device_list.end(), sort_devices);
#endif

    for (i = 0; i < device_list.size(); i++) {
        if (!device_list[i].ignore) {
            TVINSERTSTRUCTW tis;
            HTREEITEM item;
            wstring name, size;

            if (device_list[i].disk_num != 0xffffffff && device_list[i].disk_num == last_disk_num)
                tis.hParent = diskitem;
            else
                tis.hParent = TVI_ROOT;

            tis.hInsertAfter = TVI_LAST;
            tis.itemex.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
            tis.itemex.state = TVIS_EXPANDED;
            tis.itemex.stateMask = TVIS_EXPANDED;

            if (device_list[i].disk_num != 0xffffffff) {
                wstring t;

                if (!load_string(module, device_list[i].part_num != 0 ? IDS_PARTITION : IDS_DISK_NUM, t))
                    throw last_error(GetLastError());

                wstring_sprintf(name, t, device_list[i].part_num != 0 ? device_list[i].part_num : device_list[i].disk_num);
            } else
                name = device_list[i].pnp_name;

            // match child Btrfs devices to their parent
            if (bfs && device_list[i].drive == L"" && device_list[i].fstype == L"Btrfs") {
                btrfs_filesystem* bfs2 = bfs;

                while (true) {
                    if (RtlCompareMemory(&bfs2->uuid, &device_list[i].fs_uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
                        ULONG j, k;
                        btrfs_filesystem_device* dev;

                        for (j = 0; j < bfs2->num_devices; j++) {
                            if (j == 0)
                                dev = &bfs2->device;
                            else
                                dev = (btrfs_filesystem_device*)((uint8_t*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length);

                            if (RtlCompareMemory(&device_list[i].dev_uuid, &device_list[i].dev_uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
                                for (k = 0; k < device_list.size(); k++) {
                                    if (k != i && device_list[k].fstype == L"Btrfs" && device_list[k].drive != L"" &&
                                        RtlCompareMemory(&device_list[k].fs_uuid, &device_list[i].fs_uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
                                        device_list[i].drive = device_list[k].drive;
                                        break;
                                    }
                                }

                                device_list[i].multi_device = bfs2->num_devices > 1;

                                break;
                            }
                        }

                        break;
                    }

                    if (bfs2->next_entry != 0)
                        bfs2 = (btrfs_filesystem*)((uint8_t*)bfs2 + bfs2->next_entry);
                    else
                        break;
                }
            }

            name += L" (";

            if (device_list[i].friendly_name != L"") {
                name += device_list[i].friendly_name;
                name += L", ";
            }

            if (device_list[i].drive != L"") {
                name += device_list[i].drive;
                name += L", ";
            }

            if (device_list[i].fstype != L"") {
                name += device_list[i].fstype;
                name += L", ";
            }

            format_size(device_list[i].size, size, false);
            name += size;

            name += L")";

            tis.itemex.pszText = (WCHAR*)name.c_str();
            tis.itemex.cchTextMax = name.length();
            tis.itemex.lParam = (LPARAM)&device_list[i];

            item = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tis);
            if (!item)
                throw string_error(IDS_TVM_INSERTITEM_FAILED);

            if (device_list[i].part_num == 0) {
                diskitem = item;
                last_disk_num = device_list[i].disk_num;
            }
        }
    }
}

Referenced by DeviceAddDlgProc().

ShowDialog()

void BtrfsDeviceAdd::ShowDialog

(

)

Definition at line 673 of file devices.cpp.

                                {
    DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DEVICE_ADD), hwnd, stub_DeviceAddDlgProc, (LPARAM)this);
}

Referenced by AddDeviceW().

Member Data Documentation

cmdline

WCHAR* BtrfsDeviceAdd::cmdline

private

Definition at line 151 of file devices.h.

Referenced by AddDevice(), and BtrfsDeviceAdd().

device_list

vector<device> BtrfsDeviceAdd::device_list

private

Definition at line 153 of file devices.h.

Referenced by populate_device_tree().

hinst

HINSTANCE BtrfsDeviceAdd::hinst

private

Definition at line 149 of file devices.h.

Referenced by BtrfsDeviceAdd().

hwnd

HWND BtrfsDeviceAdd::hwnd

private

Definition at line 150 of file devices.h.

Referenced by BtrfsDeviceAdd().

sel

device* BtrfsDeviceAdd::sel

private

Definition at line 152 of file devices.h.

Referenced by AddDevice(), BtrfsDeviceAdd(), and DeviceAddDlgProc().

---

The documentation for this class was generated from the following files:

• dll/shellext/shellbtrfs/devices.h
• dll/shellext/shellbtrfs/devices.cpp