Remove unnecessary executable bits
[reactos.git] / dll / shellext / shellbtrfs / volpropsheet.cpp
1 /* Copyright (c) Mark Harmstone 2016-17
2 *
3 * This file is part of WinBtrfs.
4 *
5 * WinBtrfs is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public Licence as published by
7 * the Free Software Foundation, either version 3 of the Licence, or
8 * (at your option) any later version.
9 *
10 * WinBtrfs is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU Lesser General Public Licence for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public Licence
16 * along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */
17
18 #define ISOLATION_AWARE_ENABLED 1
19 #define STRSAFE_NO_DEPRECATE
20
21 #include "shellext.h"
22 #ifndef __REACTOS__
23 #include <windows.h>
24 #include <strsafe.h>
25 #include <winternl.h>
26 #else
27 #define WIN32_NO_STATUS
28 #include <windef.h>
29 #include <winbase.h>
30 #include <strsafe.h>
31 #include <ndk/iofuncs.h>
32 #include <ndk/iotypes.h>
33 #endif
34
35 #define NO_SHLWAPI_STRFCNS
36 #include <shlwapi.h>
37 #include <uxtheme.h>
38
39 #include "volpropsheet.h"
40 #include "resource.h"
41
42 HRESULT __stdcall BtrfsVolPropSheet::QueryInterface(REFIID riid, void **ppObj) {
43 if (riid == IID_IUnknown || riid == IID_IShellPropSheetExt) {
44 *ppObj = static_cast<IShellPropSheetExt*>(this);
45 AddRef();
46 return S_OK;
47 } else if (riid == IID_IShellExtInit) {
48 *ppObj = static_cast<IShellExtInit*>(this);
49 AddRef();
50 return S_OK;
51 }
52
53 *ppObj = NULL;
54 return E_NOINTERFACE;
55 }
56
57 HRESULT __stdcall BtrfsVolPropSheet::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject* pdtobj, HKEY hkeyProgID) {
58 HANDLE h;
59 ULONG num_files;
60 FORMATETC format = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
61 HDROP hdrop;
62
63 if (pidlFolder)
64 return E_FAIL;
65
66 if (!pdtobj)
67 return E_FAIL;
68
69 stgm.tymed = TYMED_HGLOBAL;
70
71 if (FAILED(pdtobj->GetData(&format, &stgm)))
72 return E_INVALIDARG;
73
74 stgm_set = TRUE;
75
76 hdrop = (HDROP)GlobalLock(stgm.hGlobal);
77
78 if (!hdrop) {
79 ReleaseStgMedium(&stgm);
80 stgm_set = FALSE;
81 return E_INVALIDARG;
82 }
83
84 num_files = DragQueryFileW((HDROP)stgm.hGlobal, 0xFFFFFFFF, NULL, 0);
85
86 if (num_files > 1) {
87 GlobalUnlock(hdrop);
88 return E_FAIL;
89 }
90
91 if (DragQueryFileW((HDROP)stgm.hGlobal, 0, fn, sizeof(fn) / sizeof(MAX_PATH))) {
92 h = CreateFileW(fn, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
93 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
94
95 if (h != INVALID_HANDLE_VALUE) {
96 NTSTATUS Status;
97 IO_STATUS_BLOCK iosb;
98 ULONG devsize, i;
99
100 i = 0;
101 devsize = 1024;
102
103 devices = (btrfs_device*)malloc(devsize);
104
105 while (TRUE) {
106 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_DEVICES, NULL, 0, devices, devsize);
107 if (Status == STATUS_BUFFER_OVERFLOW) {
108 if (i < 8) {
109 devsize += 1024;
110
111 free(devices);
112 devices = (btrfs_device*)malloc(devsize);
113
114 i++;
115 } else {
116 CloseHandle(h);
117 GlobalUnlock(hdrop);
118 return E_FAIL;
119 }
120 } else
121 break;
122 }
123
124 if (!NT_SUCCESS(Status)) {
125 CloseHandle(h);
126 GlobalUnlock(hdrop);
127 return E_FAIL;
128 }
129
130 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_UUID, NULL, 0, &uuid, sizeof(BTRFS_UUID));
131 uuid_set = NT_SUCCESS(Status);
132
133 ignore = FALSE;
134 balance = new BtrfsBalance(fn);
135
136 CloseHandle(h);
137 } else {
138 GlobalUnlock(hdrop);
139 return E_FAIL;
140 }
141 } else {
142 GlobalUnlock(hdrop);
143 return E_FAIL;
144 }
145
146 GlobalUnlock(hdrop);
147
148 return S_OK;
149 }
150
151 typedef struct {
152 UINT64 dev_id;
153 WCHAR* name;
154 UINT64 alloc;
155 UINT64 size;
156 } dev;
157
158 void BtrfsVolPropSheet::FormatUsage(HWND hwndDlg, WCHAR* s, ULONG size, btrfs_usage* usage) {
159 UINT8 i, j;
160 UINT64 num_devs, k, dev_size, dev_alloc, data_size, data_alloc, metadata_size, metadata_alloc;
161 btrfs_device* bd;
162 dev* devs = NULL;
163 btrfs_usage* bue;
164 WCHAR t[255], u[255], v[255];
165
166 static const UINT64 types[] = { BLOCK_FLAG_DATA, BLOCK_FLAG_DATA | BLOCK_FLAG_METADATA, BLOCK_FLAG_METADATA, BLOCK_FLAG_SYSTEM };
167 static const ULONG typestrings[] = { IDS_USAGE_DATA, IDS_USAGE_MIXED, IDS_USAGE_METADATA, IDS_USAGE_SYSTEM };
168 static const UINT64 duptypes[] = { 0, BLOCK_FLAG_DUPLICATE, BLOCK_FLAG_RAID0, BLOCK_FLAG_RAID1, BLOCK_FLAG_RAID10, BLOCK_FLAG_RAID5, BLOCK_FLAG_RAID6 };
169 static const ULONG dupstrings[] = { IDS_SINGLE, IDS_DUP, IDS_RAID0, IDS_RAID1, IDS_RAID10, IDS_RAID5, IDS_RAID6 };
170
171 s[0] = 0;
172
173 num_devs = 0;
174 bd = devices;
175
176 while (TRUE) {
177 num_devs++;
178
179 if (bd->next_entry > 0)
180 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
181 else
182 break;
183 }
184
185 devs = (dev*)malloc(sizeof(dev) * num_devs);
186 memset(devs, 0, sizeof(dev) * num_devs);
187
188 bd = devices;
189 k = 0;
190
191 dev_size = 0;
192
193 while (TRUE) {
194 if (bd->missing) {
195 if (!LoadStringW(module, IDS_MISSING, u, sizeof(u) / sizeof(WCHAR))) {
196 ShowError(hwndDlg, GetLastError());
197 goto end;
198 }
199
200 devs[k].name = (WCHAR*)malloc((wcslen(u) + 1) * sizeof(WCHAR));
201 wcscpy(devs[k].name, u);
202 } else if (bd->device_number == 0xffffffff) {
203 devs[k].name = (WCHAR*)malloc(bd->namelen + sizeof(WCHAR));
204 memcpy(devs[k].name, bd->name, bd->namelen);
205 devs[k].name[bd->namelen / sizeof(WCHAR)] = 0;
206 } else if (bd->partition_number == 0) {
207 if (!LoadStringW(module, IDS_DISK_NUM, u, sizeof(u) / sizeof(WCHAR))) {
208 ShowError(hwndDlg, GetLastError());
209 goto end;
210 }
211
212 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, bd->device_number) == STRSAFE_E_INSUFFICIENT_BUFFER)
213 goto end;
214
215 devs[k].name = (WCHAR*)malloc((wcslen(t) + 1) * sizeof(WCHAR));
216 wcscpy(devs[k].name, t);
217 } else {
218 if (!LoadStringW(module, IDS_DISK_PART_NUM, u, sizeof(u) / sizeof(WCHAR))) {
219 ShowError(hwndDlg, GetLastError());
220 goto end;
221 }
222
223 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, bd->device_number, bd->partition_number) == STRSAFE_E_INSUFFICIENT_BUFFER)
224 goto end;
225
226 devs[k].name = (WCHAR*)malloc((wcslen(t) + 1) * sizeof(WCHAR));
227 wcscpy(devs[k].name, t);
228 }
229
230 devs[k].dev_id = bd->dev_id;
231 devs[k].alloc = 0;
232 devs[k].size = bd->size;
233
234 dev_size += bd->size;
235
236 k++;
237
238 if (bd->next_entry > 0)
239 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
240 else
241 break;
242 }
243
244 dev_alloc = 0;
245 data_size = data_alloc = 0;
246 metadata_size = metadata_alloc = 0;
247
248 bue = usage;
249 while (TRUE) {
250 for (k = 0; k < bue->num_devices; k++) {
251 dev_alloc += bue->devices[k].alloc;
252
253 if (bue->type & BLOCK_FLAG_DATA) {
254 data_alloc += bue->devices[k].alloc;
255 }
256
257 if (bue->type & BLOCK_FLAG_METADATA) {
258 metadata_alloc += bue->devices[k].alloc;
259 }
260 }
261
262 if (bue->type & BLOCK_FLAG_DATA) {
263 data_size += bue->size;
264 }
265
266 if (bue->type & BLOCK_FLAG_METADATA) {
267 metadata_size += bue->size;
268 }
269
270 if (bue->next_entry > 0)
271 bue = (btrfs_usage*)((UINT8*)bue + bue->next_entry);
272 else
273 break;
274 }
275
276 // device size
277
278 if (!LoadStringW(module, IDS_USAGE_DEV_SIZE, u, sizeof(u) / sizeof(WCHAR))) {
279 ShowError(hwndDlg, GetLastError());
280 goto end;
281 }
282
283 format_size(dev_size, v, sizeof(v) / sizeof(WCHAR), FALSE);
284
285 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, v) == STRSAFE_E_INSUFFICIENT_BUFFER)
286 goto end;
287
288 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
289 goto end;
290
291 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
292 goto end;
293
294 // device allocated
295
296 if (!LoadStringW(module, IDS_USAGE_DEV_ALLOC, u, sizeof(u) / sizeof(WCHAR))) {
297 ShowError(hwndDlg, GetLastError());
298 goto end;
299 }
300
301 format_size(dev_alloc, v, sizeof(v) / sizeof(WCHAR), FALSE);
302
303 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, v) == STRSAFE_E_INSUFFICIENT_BUFFER)
304 goto end;
305
306 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
307 goto end;
308
309 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
310 goto end;
311
312 // device unallocated
313
314 if (!LoadStringW(module, IDS_USAGE_DEV_UNALLOC, u, sizeof(u) / sizeof(WCHAR))) {
315 ShowError(hwndDlg, GetLastError());
316 goto end;
317 }
318
319 format_size(dev_size - dev_alloc, v, sizeof(v) / sizeof(WCHAR), FALSE);
320
321 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, v) == STRSAFE_E_INSUFFICIENT_BUFFER)
322 goto end;
323
324 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
325 goto end;
326
327 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
328 goto end;
329
330 // data ratio
331
332 if (data_alloc > 0) {
333 if (!LoadStringW(module, IDS_USAGE_DATA_RATIO, u, sizeof(u) / sizeof(WCHAR))) {
334 ShowError(hwndDlg, GetLastError());
335 goto end;
336 }
337
338 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, (float)data_alloc / (float)data_size) == STRSAFE_E_INSUFFICIENT_BUFFER)
339 goto end;
340
341 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
342 goto end;
343
344 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
345 goto end;
346 }
347
348 // metadata ratio
349
350 if (!LoadStringW(module, IDS_USAGE_METADATA_RATIO, u, sizeof(u) / sizeof(WCHAR))) {
351 ShowError(hwndDlg, GetLastError());
352 goto end;
353 }
354
355 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), u, (float)metadata_alloc / (float)metadata_size) == STRSAFE_E_INSUFFICIENT_BUFFER)
356 goto end;
357
358 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
359 goto end;
360
361 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
362 goto end;
363
364 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
365 goto end;
366
367 for (i = 0; i < sizeof(types) / sizeof(types[0]); i++) {
368 for (j = 0; j < sizeof(duptypes) / sizeof(duptypes[0]); j++) {
369 bue = usage;
370
371 while (TRUE) {
372 if ((bue->type & types[i]) == types[i] &&
373 ((duptypes[j] == 0 && (bue->type & (BLOCK_FLAG_DUPLICATE | BLOCK_FLAG_RAID0 | BLOCK_FLAG_RAID1 | BLOCK_FLAG_RAID10 | BLOCK_FLAG_RAID5 | BLOCK_FLAG_RAID6)) == 0)
374 || bue->type & duptypes[j])) {
375 WCHAR typestring[255], dupstring[255], sizestring[255], usedstring[255];
376
377 if (bue->type & BLOCK_FLAG_DATA && bue->type & BLOCK_FLAG_METADATA && (types[i] == BLOCK_FLAG_DATA || types[i] == BLOCK_FLAG_METADATA))
378 break;
379
380 if (!LoadStringW(module, typestrings[i], typestring, sizeof(typestring) / sizeof(WCHAR))) {
381 ShowError(hwndDlg, GetLastError());
382 goto end;
383 }
384
385 if (!LoadStringW(module, dupstrings[j], dupstring, sizeof(dupstring) / sizeof(WCHAR))) {
386 ShowError(hwndDlg, GetLastError());
387 goto end;
388 }
389
390 format_size(bue->size, sizestring, sizeof(sizestring) / sizeof(WCHAR), FALSE);
391 format_size(bue->used, usedstring, sizeof(usedstring) / sizeof(WCHAR), FALSE);
392
393 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), typestring, dupstring, sizestring, usedstring) == STRSAFE_E_INSUFFICIENT_BUFFER)
394 goto end;
395
396 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
397 goto end;
398
399 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
400 goto end;
401
402 for (k = 0; k < bue->num_devices; k++) {
403 UINT64 l;
404 BOOL found = FALSE;
405
406 format_size(bue->devices[k].alloc, sizestring, sizeof(sizestring) / sizeof(WCHAR), FALSE);
407
408 for (l = 0; l < num_devs; l++) {
409 if (devs[l].dev_id == bue->devices[k].dev_id) {
410 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), L"%s\t%s", devs[l].name, sizestring) == STRSAFE_E_INSUFFICIENT_BUFFER)
411 goto end;
412
413 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
414 goto end;
415
416 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
417 goto end;
418
419 devs[l].alloc += bue->devices[k].alloc;
420
421 found = TRUE;
422 break;
423 }
424 }
425
426 if (!found) {
427 if (!LoadStringW(module, IDS_UNKNOWN_DEVICE, typestring, sizeof(typestring) / sizeof(WCHAR))) {
428 ShowError(hwndDlg, GetLastError());
429 goto end;
430 }
431
432 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), typestring, bue->devices[k].dev_id) == STRSAFE_E_INSUFFICIENT_BUFFER)
433 goto end;
434
435 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
436 goto end;
437
438 if (StringCchCatW(s, size, L"\t") == STRSAFE_E_INSUFFICIENT_BUFFER)
439 goto end;
440
441 if (StringCchCatW(s, size, sizestring) == STRSAFE_E_INSUFFICIENT_BUFFER)
442 goto end;
443
444 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
445 goto end;
446 }
447 }
448
449 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
450 goto end;
451
452 break;
453 }
454
455 if (bue->next_entry > 0)
456 bue = (btrfs_usage*)((UINT8*)bue + bue->next_entry);
457 else
458 break;
459 }
460 }
461 }
462
463 if (!LoadStringW(module, IDS_USAGE_UNALLOC, t, sizeof(t) / sizeof(WCHAR))) {
464 ShowError(hwndDlg, GetLastError());
465 goto end;
466 }
467
468 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
469 goto end;
470
471 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
472 goto end;
473
474 for (k = 0; k < num_devs; k++) {
475 WCHAR sizestring[255];
476
477 format_size(devs[k].size - devs[k].alloc, sizestring, sizeof(sizestring) / sizeof(WCHAR), FALSE);
478
479 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), L"%s\t%s", devs[k].name, sizestring) == STRSAFE_E_INSUFFICIENT_BUFFER)
480 goto end;
481
482 if (StringCchCatW(s, size, t) == STRSAFE_E_INSUFFICIENT_BUFFER)
483 goto end;
484
485 if (StringCchCatW(s, size, L"\r\n") == STRSAFE_E_INSUFFICIENT_BUFFER)
486 goto end;
487 }
488
489 end:
490 if (devs) {
491 for (k = 0; k < num_devs; k++) {
492 if (devs[k].name) free(devs[k].name);
493 }
494
495 free(devs);
496 }
497 }
498
499 void BtrfsVolPropSheet::RefreshUsage(HWND hwndDlg) {
500 HANDLE h;
501 WCHAR s[4096];
502 btrfs_usage* usage;
503
504 h = CreateFileW(fn, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
505 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
506
507 if (h != INVALID_HANDLE_VALUE) {
508 NTSTATUS Status;
509 IO_STATUS_BLOCK iosb;
510 ULONG devsize, usagesize, i;
511
512 i = 0;
513 devsize = 1024;
514
515 devices = (btrfs_device*)malloc(devsize);
516
517 while (TRUE) {
518 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_DEVICES, NULL, 0, devices, devsize);
519 if (Status == STATUS_BUFFER_OVERFLOW) {
520 if (i < 8) {
521 devsize += 1024;
522
523 free(devices);
524 devices = (btrfs_device*)malloc(devsize);
525
526 i++;
527 } else
528 return;
529 } else
530 break;
531 }
532
533 if (!NT_SUCCESS(Status)) {
534 CloseHandle(h);
535 return;
536 }
537
538 i = 0;
539 usagesize = 1024;
540
541 usage = (btrfs_usage*)malloc(usagesize);
542
543 while (TRUE) {
544 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_USAGE, NULL, 0, usage, usagesize);
545 if (Status == STATUS_BUFFER_OVERFLOW) {
546 if (i < 8) {
547 usagesize += 1024;
548
549 free(usage);
550 usage = (btrfs_usage*)malloc(usagesize);
551
552 i++;
553 } else
554 return;
555 } else
556 break;
557 }
558
559 if (!NT_SUCCESS(Status)) {
560 free(usage);
561 CloseHandle(h);
562 return;
563 }
564
565 ignore = FALSE;
566
567 CloseHandle(h);
568 } else
569 return;
570
571 FormatUsage(hwndDlg, s, sizeof(s) / sizeof(WCHAR), usage);
572
573 SetDlgItemTextW(hwndDlg, IDC_USAGE_BOX, s);
574
575 free(usage);
576 }
577
578 INT_PTR CALLBACK BtrfsVolPropSheet::UsageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
579 switch (uMsg) {
580 case WM_INITDIALOG:
581 {
582 WCHAR s[4096];
583 int i;
584 ULONG usagesize;
585 NTSTATUS Status;
586 HANDLE h;
587 IO_STATUS_BLOCK iosb;
588
589 EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
590
591 h = CreateFileW(fn, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
592 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
593
594 if (h != INVALID_HANDLE_VALUE) {
595 btrfs_usage* usage;
596
597 i = 0;
598 usagesize = 1024;
599
600 usage = (btrfs_usage*)malloc(usagesize);
601
602 while (TRUE) {
603 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_USAGE, NULL, 0, usage, usagesize);
604 if (Status == STATUS_BUFFER_OVERFLOW) {
605 if (i < 8) {
606 usagesize += 1024;
607
608 free(usage);
609 usage = (btrfs_usage*)malloc(usagesize);
610
611 i++;
612 } else
613 break;
614 } else
615 break;
616 }
617
618 if (!NT_SUCCESS(Status)) {
619 free(usage);
620 CloseHandle(h);
621 break;
622 }
623
624 CloseHandle(h);
625
626 FormatUsage(hwndDlg, s, sizeof(s) / sizeof(WCHAR), usage);
627
628 SetDlgItemTextW(hwndDlg, IDC_USAGE_BOX, s);
629
630 free(usage);
631 }
632
633 break;
634 }
635
636 case WM_COMMAND:
637 switch (HIWORD(wParam)) {
638 case BN_CLICKED:
639 switch (LOWORD(wParam)) {
640 case IDOK:
641 case IDCANCEL:
642 EndDialog(hwndDlg, 0);
643 return TRUE;
644
645 case IDC_USAGE_REFRESH:
646 RefreshUsage(hwndDlg);
647 return TRUE;
648 }
649 break;
650 }
651 break;
652 }
653
654 return FALSE;
655 }
656
657 static INT_PTR CALLBACK stub_UsageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
658 BtrfsVolPropSheet* bvps;
659
660 if (uMsg == WM_INITDIALOG) {
661 SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
662 bvps = (BtrfsVolPropSheet*)lParam;
663 } else {
664 bvps = (BtrfsVolPropSheet*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
665 }
666
667 if (bvps)
668 return bvps->UsageDlgProc(hwndDlg, uMsg, wParam, lParam);
669 else
670 return FALSE;
671 }
672
673 void BtrfsVolPropSheet::ShowUsage(HWND hwndDlg) {
674 DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_VOL_USAGE), hwndDlg, stub_UsageDlgProc, (LPARAM)this);
675 }
676
677 static void add_lv_column(HWND list, int string, int cx) {
678 LVCOLUMNW lvc;
679 WCHAR s[255];
680
681 if (!LoadStringW(module, string, s, sizeof(s) / sizeof(WCHAR))) {
682 ShowError(GetParent(list), GetLastError());
683 return;
684 }
685
686 lvc.mask = LVCF_TEXT|LVCF_WIDTH;
687 lvc.pszText = s;
688 lvc.cx = cx;
689 SendMessageW(list, LVM_INSERTCOLUMNW, 0, (LPARAM)&lvc);
690 }
691
692 static int CALLBACK lv_sort(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort) {
693 if (lParam1 < lParam2)
694 return -1;
695 else if (lParam1 > lParam2)
696 return 1;
697 else
698 return 0;
699 }
700
701 static UINT64 find_dev_alloc(UINT64 dev_id, btrfs_usage* usage) {
702 btrfs_usage* bue;
703 UINT64 alloc;
704
705 alloc = 0;
706
707 bue = usage;
708 while (TRUE) {
709 UINT64 k;
710
711 for (k = 0; k < bue->num_devices; k++) {
712 if (bue->devices[k].dev_id == dev_id)
713 alloc += bue->devices[k].alloc;
714 }
715
716 if (bue->next_entry > 0)
717 bue = (btrfs_usage*)((UINT8*)bue + bue->next_entry);
718 else
719 break;
720 }
721
722 return alloc;
723 }
724
725 void BtrfsVolPropSheet::RefreshDevList(HWND devlist) {
726 HANDLE h;
727 NTSTATUS Status;
728 IO_STATUS_BLOCK iosb;
729 ULONG usagesize, devsize;
730 btrfs_usage* usage;
731 btrfs_device* bd;
732 int i;
733 UINT64 num_rw_devices;
734
735 h = CreateFileW(fn, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
736 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
737
738 if (h == INVALID_HANDLE_VALUE) {
739 ShowError(GetParent(devlist), GetLastError());
740 return;
741 }
742
743 i = 0;
744 devsize = 1024;
745
746 if (devices)
747 free(devices);
748
749 devices = (btrfs_device*)malloc(devsize);
750
751 while (TRUE) {
752 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_DEVICES, NULL, 0, devices, devsize);
753 if (Status == STATUS_BUFFER_OVERFLOW) {
754 if (i < 8) {
755 devsize += 1024;
756
757 free(devices);
758 devices = (btrfs_device*)malloc(devsize);
759
760 i++;
761 } else
762 return;
763 } else
764 break;
765 }
766
767 if (!NT_SUCCESS(Status)) {
768 CloseHandle(h);
769 return;
770 }
771
772 bd = devices;
773
774 i = 0;
775 usagesize = 1024;
776
777 usage = (btrfs_usage*)malloc(usagesize);
778
779 while (TRUE) {
780 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_USAGE, NULL, 0, usage, usagesize);
781 if (Status == STATUS_BUFFER_OVERFLOW) {
782 if (i < 8) {
783 usagesize += 1024;
784
785 free(usage);
786 usage = (btrfs_usage*)malloc(usagesize);
787
788 i++;
789 } else {
790 free(usage);
791 CloseHandle(h);
792 return;
793 }
794 } else
795 break;
796 }
797
798 if (!NT_SUCCESS(Status)) {
799 free(usage);
800 CloseHandle(h);
801 return;
802 }
803
804 CloseHandle(h);
805
806 SendMessageW(devlist, LVM_DELETEALLITEMS, 0, 0);
807
808 num_rw_devices = 0;
809
810 i = 0;
811 while (TRUE) {
812 LVITEMW lvi;
813 WCHAR s[255], u[255];
814 UINT64 alloc;
815
816 // ID
817
818 RtlZeroMemory(&lvi, sizeof(LVITEMW));
819 lvi.mask = LVIF_TEXT | LVIF_PARAM;
820 lvi.iItem = SendMessageW(devlist, LVM_GETITEMCOUNT, 0, 0);
821 lvi.lParam = bd->dev_id;
822
823 StringCchPrintfW(s, sizeof(s) / sizeof(WCHAR), L"%llu", bd->dev_id);
824 lvi.pszText = s;
825
826 SendMessageW(devlist, LVM_INSERTITEMW, 0, (LPARAM)&lvi);
827
828 // description
829
830 lvi.mask = LVIF_TEXT;
831 lvi.iSubItem = 1;
832
833 if (bd->missing) {
834 if (!LoadStringW(module, IDS_MISSING, u, sizeof(u) / sizeof(WCHAR))) {
835 ShowError(GetParent(devlist), GetLastError());
836 break;
837 }
838
839 wcscpy(s, u);
840 } else if (bd->device_number == 0xffffffff) {
841 memcpy(s, bd->name, bd->namelen);
842 s[bd->namelen / sizeof(WCHAR)] = 0;
843 } else if (bd->partition_number == 0) {
844 if (!LoadStringW(module, IDS_DISK_NUM, u, sizeof(u) / sizeof(WCHAR))) {
845 ShowError(GetParent(devlist), GetLastError());
846 break;
847 }
848
849 if (StringCchPrintfW(s, sizeof(s) / sizeof(WCHAR), u, bd->device_number) == STRSAFE_E_INSUFFICIENT_BUFFER)
850 break;
851 } else {
852 if (!LoadStringW(module, IDS_DISK_PART_NUM, u, sizeof(u) / sizeof(WCHAR))) {
853 ShowError(GetParent(devlist), GetLastError());
854 break;
855 }
856
857 if (StringCchPrintfW(s, sizeof(s) / sizeof(WCHAR), u, bd->device_number, bd->partition_number) == STRSAFE_E_INSUFFICIENT_BUFFER)
858 break;
859 }
860
861 lvi.pszText = s;
862
863 SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
864
865 // readonly
866
867 lvi.iSubItem = 2;
868 LoadStringW(module, bd->readonly ? IDS_DEVLIST_READONLY_YES : IDS_DEVLIST_READONLY_NO, s, sizeof(s) / sizeof(WCHAR));
869 lvi.pszText = s;
870 SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
871
872 if (!bd->readonly)
873 num_rw_devices++;
874
875 // size
876
877 lvi.iSubItem = 3;
878 format_size(bd->size, s, sizeof(s) / sizeof(WCHAR), FALSE);
879 lvi.pszText = s;
880 SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
881
882 // alloc
883
884 alloc = find_dev_alloc(bd->dev_id, usage);
885
886 lvi.iSubItem = 4;
887 format_size(alloc, s, sizeof(s) / sizeof(WCHAR), FALSE);
888 lvi.pszText = s;
889 SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
890
891 // alloc %
892
893 StringCchPrintfW(s, sizeof(s) / sizeof(WCHAR), L"%1.1f%%", (float)alloc * 100.0f / (float)bd->size);
894 lvi.iSubItem = 5;
895 lvi.pszText = s;
896 SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
897
898 i++;
899
900 if (bd->next_entry > 0)
901 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
902 else
903 break;
904 }
905
906 free(usage);
907
908 SendMessageW(devlist, LVM_SORTITEMS, 0, (LPARAM)lv_sort);
909
910 EnableWindow(GetDlgItem(GetParent(devlist), IDC_DEVICE_ADD), num_rw_devices > 0);
911 EnableWindow(GetDlgItem(GetParent(devlist), IDC_DEVICE_REMOVE), num_rw_devices > 1);
912 }
913
914 void BtrfsVolPropSheet::ResetStats(HWND hwndDlg) {
915 HANDLE h;
916 WCHAR t[MAX_PATH + 100], sel[10];
917 SHELLEXECUTEINFOW sei;
918
919 _itow(stats_dev, sel, 10);
920
921 t[0] = '"';
922 GetModuleFileNameW(module, t + 1, (sizeof(t) / sizeof(WCHAR)) - 1);
923 wcscat(t, L"\",ResetStats ");
924 wcscat(t, fn);
925 wcscat(t, L"|");
926 wcscat(t, sel);
927
928 RtlZeroMemory(&sei, sizeof(sei));
929
930 sei.cbSize = sizeof(sei);
931 sei.hwnd = hwndDlg;
932 sei.lpVerb = L"runas";
933 sei.lpFile = L"rundll32.exe";
934 sei.lpParameters = t;
935 sei.nShow = SW_SHOW;
936 sei.fMask = SEE_MASK_NOCLOSEPROCESS;
937
938 if (!ShellExecuteExW(&sei)) {
939 ShowError(hwndDlg, GetLastError());
940 return;
941 }
942
943 WaitForSingleObject(sei.hProcess, INFINITE);
944 CloseHandle(sei.hProcess);
945
946 h = CreateFileW(fn, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
947 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
948
949 if (h != INVALID_HANDLE_VALUE) {
950 NTSTATUS Status;
951 IO_STATUS_BLOCK iosb;
952 ULONG devsize, i;
953
954 i = 0;
955 devsize = 1024;
956
957 free(devices);
958 devices = (btrfs_device*)malloc(devsize);
959
960 while (TRUE) {
961 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_GET_DEVICES, NULL, 0, devices, devsize);
962 if (Status == STATUS_BUFFER_OVERFLOW) {
963 if (i < 8) {
964 devsize += 1024;
965
966 free(devices);
967 devices = (btrfs_device*)malloc(devsize);
968
969 i++;
970 } else
971 break;
972 } else
973 break;
974 }
975
976 CloseHandle(h);
977 }
978
979 EndDialog(hwndDlg, 0);
980 }
981
982 INT_PTR CALLBACK BtrfsVolPropSheet::StatsDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
983 switch (uMsg) {
984 case WM_INITDIALOG:
985 {
986 WCHAR s[255], t[255];
987 btrfs_device *bd, *dev = NULL;
988 int i;
989
990 static int stat_ids[] = { IDC_WRITE_ERRS, IDC_READ_ERRS, IDC_FLUSH_ERRS, IDC_CORRUPTION_ERRS, IDC_GENERATION_ERRS };
991
992 bd = devices;
993
994 while (TRUE) {
995 if (bd->dev_id == stats_dev) {
996 dev = bd;
997 break;
998 }
999
1000 if (bd->next_entry > 0)
1001 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
1002 else
1003 break;
1004 }
1005
1006 if (!dev) {
1007 EndDialog(hwndDlg, 0);
1008 ShowStringError(hwndDlg, IDS_CANNOT_FIND_DEVICE);
1009 return FALSE;
1010 }
1011
1012 GetDlgItemTextW(hwndDlg, IDC_DEVICE_ID, s, sizeof(s) / sizeof(WCHAR));
1013
1014 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), s, dev->dev_id) == STRSAFE_E_INSUFFICIENT_BUFFER)
1015 return FALSE;
1016
1017 SetDlgItemTextW(hwndDlg, IDC_DEVICE_ID, t);
1018
1019 for (i = 0; i < 5; i++) {
1020 GetDlgItemTextW(hwndDlg, stat_ids[i], s, sizeof(s) / sizeof(WCHAR));
1021
1022 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), s, dev->stats[i]) == STRSAFE_E_INSUFFICIENT_BUFFER)
1023 return FALSE;
1024
1025 SetDlgItemTextW(hwndDlg, stat_ids[i], t);
1026 }
1027
1028 SendMessageW(GetDlgItem(hwndDlg, IDC_RESET_STATS), BCM_SETSHIELD, 0, TRUE);
1029 EnableWindow(GetDlgItem(hwndDlg, IDC_RESET_STATS), !readonly);
1030
1031 break;
1032 }
1033
1034 case WM_COMMAND:
1035 switch (HIWORD(wParam)) {
1036 case BN_CLICKED:
1037 switch (LOWORD(wParam)) {
1038 case IDOK:
1039 case IDCANCEL:
1040 EndDialog(hwndDlg, 0);
1041 return TRUE;
1042
1043 case IDC_RESET_STATS:
1044 ResetStats(hwndDlg);
1045 return TRUE;
1046 }
1047 break;
1048 }
1049 break;
1050 }
1051
1052 return FALSE;
1053 }
1054
1055 static INT_PTR CALLBACK stub_StatsDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
1056 BtrfsVolPropSheet* bvps;
1057
1058 if (uMsg == WM_INITDIALOG) {
1059 SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
1060 bvps = (BtrfsVolPropSheet*)lParam;
1061 } else {
1062 bvps = (BtrfsVolPropSheet*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
1063 }
1064
1065 if (bvps)
1066 return bvps->StatsDlgProc(hwndDlg, uMsg, wParam, lParam);
1067 else
1068 return FALSE;
1069 }
1070
1071 void BtrfsVolPropSheet::ShowStats(HWND hwndDlg, UINT64 devid) {
1072 stats_dev = devid;
1073
1074 DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DEVICE_STATS), hwndDlg, stub_StatsDlgProc, (LPARAM)this);
1075 }
1076
1077 INT_PTR CALLBACK BtrfsVolPropSheet::DeviceDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
1078 switch (uMsg) {
1079 case WM_INITDIALOG:
1080 {
1081 HWND devlist;
1082 RECT rect;
1083 ULONG w;
1084
1085 EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
1086
1087 devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
1088
1089 GetClientRect(devlist, &rect);
1090 w = rect.right - rect.left;
1091
1092 add_lv_column(devlist, IDS_DEVLIST_ALLOC_PC, w * 5 / 44);
1093 add_lv_column(devlist, IDS_DEVLIST_ALLOC, w * 6 / 44);
1094 add_lv_column(devlist, IDS_DEVLIST_SIZE, w * 6 / 44);
1095 add_lv_column(devlist, IDS_DEVLIST_READONLY, w * 7 / 44);
1096 add_lv_column(devlist, IDS_DEVLIST_DESC, w * 16 / 44);
1097 add_lv_column(devlist, IDS_DEVLIST_ID, w * 4 / 44);
1098
1099 SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_ADD), BCM_SETSHIELD, 0, TRUE);
1100 SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_REMOVE), BCM_SETSHIELD, 0, TRUE);
1101 SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), BCM_SETSHIELD, 0, TRUE);
1102
1103 RefreshDevList(devlist);
1104
1105 break;
1106 }
1107
1108 case WM_COMMAND:
1109 switch (HIWORD(wParam)) {
1110 case BN_CLICKED:
1111 switch (LOWORD(wParam)) {
1112 case IDOK:
1113 case IDCANCEL:
1114 KillTimer(hwndDlg, 1);
1115 EndDialog(hwndDlg, 0);
1116 return TRUE;
1117
1118 case IDC_DEVICE_ADD:
1119 {
1120 WCHAR t[MAX_PATH + 100];
1121 SHELLEXECUTEINFOW sei;
1122
1123 t[0] = '"';
1124 GetModuleFileNameW(module, t + 1, (sizeof(t) / sizeof(WCHAR)) - 1);
1125 wcscat(t, L"\",AddDevice ");
1126 wcscat(t, fn);
1127
1128 RtlZeroMemory(&sei, sizeof(sei));
1129
1130 sei.cbSize = sizeof(sei);
1131 sei.hwnd = hwndDlg;
1132 sei.lpVerb = L"runas";
1133 sei.lpFile = L"rundll32.exe";
1134 sei.lpParameters = t;
1135 sei.nShow = SW_SHOW;
1136 sei.fMask = SEE_MASK_NOCLOSEPROCESS;
1137
1138 if (!ShellExecuteExW(&sei)) {
1139 ShowError(hwndDlg, GetLastError());
1140 return TRUE;
1141 }
1142
1143 WaitForSingleObject(sei.hProcess, INFINITE);
1144 CloseHandle(sei.hProcess);
1145
1146 RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
1147
1148 return TRUE;
1149 }
1150
1151 case IDC_DEVICE_REFRESH:
1152 RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
1153 return TRUE;
1154
1155 case IDC_DEVICE_SHOW_STATS:
1156 {
1157 WCHAR sel[MAX_PATH];
1158 HWND devlist;
1159 int index;
1160 LVITEMW lvi;
1161
1162 devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
1163
1164 index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
1165
1166 if (index == -1)
1167 return TRUE;
1168
1169 RtlZeroMemory(&lvi, sizeof(LVITEMW));
1170 lvi.mask = LVIF_TEXT;
1171 lvi.iItem = index;
1172 lvi.iSubItem = 0;
1173 lvi.pszText = sel;
1174 lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
1175 SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
1176
1177 ShowStats(hwndDlg, _wtoi(sel));
1178 return TRUE;
1179 }
1180
1181 case IDC_DEVICE_REMOVE:
1182 {
1183 WCHAR t[2*MAX_PATH + 100], sel[MAX_PATH], sel2[MAX_PATH], mess[255], mess2[255], title[255];
1184 HWND devlist;
1185 SHELLEXECUTEINFOW sei;
1186 int index;
1187 LVITEMW lvi;
1188
1189 devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
1190
1191 index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
1192
1193 if (index == -1)
1194 return TRUE;
1195
1196 RtlZeroMemory(&lvi, sizeof(LVITEMW));
1197 lvi.mask = LVIF_TEXT;
1198 lvi.iItem = index;
1199 lvi.iSubItem = 0;
1200 lvi.pszText = sel;
1201 lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
1202 SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
1203
1204 lvi.iSubItem = 1;
1205 lvi.pszText = sel2;
1206 lvi.cchTextMax = sizeof(sel2) / sizeof(WCHAR);
1207 SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
1208
1209 if (!LoadStringW(module, IDS_REMOVE_DEVICE_CONFIRMATION, mess, sizeof(mess) / sizeof(WCHAR))) {
1210 ShowError(hwndDlg, GetLastError());
1211 return TRUE;
1212 }
1213
1214 if (StringCchPrintfW(mess2, sizeof(mess2) / sizeof(WCHAR), mess, sel, sel2) == STRSAFE_E_INSUFFICIENT_BUFFER)
1215 return TRUE;
1216
1217 if (!LoadStringW(module, IDS_CONFIRMATION_TITLE, title, sizeof(title) / sizeof(WCHAR))) {
1218 ShowError(hwndDlg, GetLastError());
1219 return TRUE;
1220 }
1221
1222 if (MessageBoxW(hwndDlg, mess2, title, MB_YESNO) != IDYES)
1223 return TRUE;
1224
1225 t[0] = '"';
1226 GetModuleFileNameW(module, t + 1, (sizeof(t) / sizeof(WCHAR)) - 1);
1227 wcscat(t, L"\",RemoveDevice ");
1228 wcscat(t, fn);
1229 wcscat(t, L"|");
1230 wcscat(t, sel);
1231
1232 RtlZeroMemory(&sei, sizeof(sei));
1233
1234 sei.cbSize = sizeof(sei);
1235 sei.hwnd = hwndDlg;
1236 sei.lpVerb = L"runas";
1237 sei.lpFile = L"rundll32.exe";
1238 sei.lpParameters = t;
1239 sei.nShow = SW_SHOW;
1240 sei.fMask = SEE_MASK_NOCLOSEPROCESS;
1241
1242 if (!ShellExecuteExW(&sei)) {
1243 ShowError(hwndDlg, GetLastError());
1244 return TRUE;
1245 }
1246
1247 WaitForSingleObject(sei.hProcess, INFINITE);
1248 CloseHandle(sei.hProcess);
1249
1250 RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
1251
1252 return TRUE;
1253 }
1254
1255 case IDC_DEVICE_RESIZE:
1256 {
1257 HWND devlist;
1258 int index;
1259 LVITEMW lvi;
1260 WCHAR sel[100], t[2*MAX_PATH + 100];
1261 SHELLEXECUTEINFOW sei;
1262
1263 devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
1264
1265 index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
1266
1267 if (index == -1)
1268 return TRUE;
1269
1270 RtlZeroMemory(&lvi, sizeof(LVITEMW));
1271 lvi.mask = LVIF_TEXT;
1272 lvi.iItem = index;
1273 lvi.iSubItem = 0;
1274 lvi.pszText = sel;
1275 lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
1276 SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
1277
1278 t[0] = '"';
1279 GetModuleFileNameW(module, t + 1, (sizeof(t) / sizeof(WCHAR)) - 1);
1280 wcscat(t, L"\",ResizeDevice ");
1281 wcscat(t, fn);
1282 wcscat(t, L"|");
1283 wcscat(t, sel);
1284
1285 RtlZeroMemory(&sei, sizeof(sei));
1286
1287 sei.cbSize = sizeof(sei);
1288 sei.hwnd = hwndDlg;
1289 sei.lpVerb = L"runas";
1290 sei.lpFile = L"rundll32.exe";
1291 sei.lpParameters = t;
1292 sei.nShow = SW_SHOW;
1293 sei.fMask = SEE_MASK_NOCLOSEPROCESS;
1294
1295 if (!ShellExecuteExW(&sei)) {
1296 ShowError(hwndDlg, GetLastError());
1297 return TRUE;
1298 }
1299
1300 WaitForSingleObject(sei.hProcess, INFINITE);
1301 CloseHandle(sei.hProcess);
1302
1303 RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
1304 }
1305 }
1306 break;
1307 }
1308 break;
1309
1310 case WM_NOTIFY:
1311 switch (((LPNMHDR)lParam)->code) {
1312 case LVN_ITEMCHANGED:
1313 {
1314 NMLISTVIEW* nmv = (NMLISTVIEW*)lParam;
1315
1316 EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_SHOW_STATS), nmv->uNewState & LVIS_SELECTED);
1317
1318 if (nmv->uNewState & LVIS_SELECTED && !readonly) {
1319 HWND devlist;
1320 btrfs_device* bd;
1321 BOOL device_readonly = FALSE;
1322 LVITEMW lvi;
1323 WCHAR sel[MAX_PATH];
1324 UINT64 devid;
1325
1326 devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
1327
1328 RtlZeroMemory(&lvi, sizeof(LVITEMW));
1329 lvi.mask = LVIF_TEXT;
1330 lvi.iItem = nmv->iItem;
1331 lvi.iSubItem = 0;
1332 lvi.pszText = sel;
1333 lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
1334 SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
1335 devid = _wtoi(sel);
1336
1337 bd = devices;
1338
1339 while (TRUE) {
1340 if (bd->dev_id == devid) {
1341 device_readonly = bd->readonly;
1342 break;
1343 }
1344
1345 if (bd->next_entry > 0)
1346 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
1347 else
1348 break;
1349 }
1350
1351 EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), !device_readonly);
1352 } else
1353 EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), FALSE);
1354
1355 break;
1356 }
1357 }
1358 break;
1359 }
1360
1361 return FALSE;
1362 }
1363
1364 static INT_PTR CALLBACK stub_DeviceDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
1365 BtrfsVolPropSheet* bvps;
1366
1367 if (uMsg == WM_INITDIALOG) {
1368 SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
1369 bvps = (BtrfsVolPropSheet*)lParam;
1370 } else {
1371 bvps = (BtrfsVolPropSheet*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
1372 }
1373
1374 if (bvps)
1375 return bvps->DeviceDlgProc(hwndDlg, uMsg, wParam, lParam);
1376 else
1377 return FALSE;
1378 }
1379
1380 void BtrfsVolPropSheet::ShowDevices(HWND hwndDlg) {
1381 DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DEVICES), hwndDlg, stub_DeviceDlgProc, (LPARAM)this);
1382 }
1383
1384 void BtrfsVolPropSheet::ShowScrub(HWND hwndDlg) {
1385 WCHAR t[MAX_PATH + 100];
1386 SHELLEXECUTEINFOW sei;
1387
1388 t[0] = '"';
1389 GetModuleFileNameW(module, t + 1, (sizeof(t) / sizeof(WCHAR)) - 1);
1390 wcscat(t, L"\",ShowScrub ");
1391 wcscat(t, fn);
1392
1393 RtlZeroMemory(&sei, sizeof(sei));
1394
1395 sei.cbSize = sizeof(sei);
1396 sei.hwnd = hwndDlg;
1397 sei.lpVerb = L"runas";
1398 sei.lpFile = L"rundll32.exe";
1399 sei.lpParameters = t;
1400 sei.nShow = SW_SHOW;
1401 sei.fMask = SEE_MASK_NOCLOSEPROCESS;
1402
1403 if (!ShellExecuteExW(&sei)) {
1404 ShowError(hwndDlg, GetLastError());
1405 return;
1406 }
1407
1408 WaitForSingleObject(sei.hProcess, INFINITE);
1409 CloseHandle(sei.hProcess);
1410 }
1411
1412 static INT_PTR CALLBACK PropSheetDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
1413 switch (uMsg) {
1414 case WM_INITDIALOG:
1415 {
1416 PROPSHEETPAGE* psp = (PROPSHEETPAGE*)lParam;
1417 BtrfsVolPropSheet* bps = (BtrfsVolPropSheet*)psp->lParam;
1418 btrfs_device* bd;
1419
1420 EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
1421
1422 SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)bps);
1423
1424 bps->readonly = TRUE;
1425 bd = bps->devices;
1426
1427 while (TRUE) {
1428 if (!bd->readonly) {
1429 bps->readonly = FALSE;
1430 break;
1431 }
1432
1433 if (bd->next_entry > 0)
1434 bd = (btrfs_device*)((UINT8*)bd + bd->next_entry);
1435 else
1436 break;
1437 }
1438
1439 if (bps->uuid_set) {
1440 WCHAR s[255], t[255];
1441
1442 GetDlgItemTextW(hwndDlg, IDC_UUID, s, sizeof(s) / sizeof(WCHAR));
1443
1444 if (StringCchPrintfW(t, sizeof(t) / sizeof(WCHAR), s,
1445 bps->uuid.uuid[0], bps->uuid.uuid[1], bps->uuid.uuid[2], bps->uuid.uuid[3], bps->uuid.uuid[4], bps->uuid.uuid[5], bps->uuid.uuid[6], bps->uuid.uuid[7],
1446 bps->uuid.uuid[8], bps->uuid.uuid[9], bps->uuid.uuid[10], bps->uuid.uuid[11], bps->uuid.uuid[12], bps->uuid.uuid[13], bps->uuid.uuid[14], bps->uuid.uuid[15]
1447 ) != STRSAFE_E_INSUFFICIENT_BUFFER)
1448 SetDlgItemTextW(hwndDlg, IDC_UUID, t);
1449 else
1450 SetDlgItemTextW(hwndDlg, IDC_UUID, L"");
1451 } else
1452 SetDlgItemTextW(hwndDlg, IDC_UUID, L"");
1453
1454 SendMessageW(GetDlgItem(hwndDlg, IDC_VOL_SCRUB), BCM_SETSHIELD, 0, TRUE);
1455
1456 return FALSE;
1457 }
1458
1459 case WM_NOTIFY:
1460 {
1461 switch (((LPNMHDR)lParam)->code) {
1462 case PSN_KILLACTIVE:
1463 SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, FALSE);
1464 break;
1465 }
1466 break;
1467 }
1468
1469 case WM_COMMAND:
1470 {
1471 BtrfsVolPropSheet* bps = (BtrfsVolPropSheet*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
1472
1473 if (bps) {
1474 switch (HIWORD(wParam)) {
1475 case BN_CLICKED: {
1476 switch (LOWORD(wParam)) {
1477 case IDC_VOL_SHOW_USAGE:
1478 bps->ShowUsage(hwndDlg);
1479 break;
1480
1481 case IDC_VOL_BALANCE:
1482 bps->balance->ShowBalance(hwndDlg);
1483 break;
1484
1485 case IDC_VOL_DEVICES:
1486 bps->ShowDevices(hwndDlg);
1487 break;
1488
1489 case IDC_VOL_SCRUB:
1490 bps->ShowScrub(hwndDlg);
1491 break;
1492 }
1493 }
1494 }
1495 }
1496
1497 break;
1498 }
1499 }
1500
1501 return FALSE;
1502 }
1503
1504 HRESULT __stdcall BtrfsVolPropSheet::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam) {
1505 PROPSHEETPAGE psp;
1506 HPROPSHEETPAGE hPage;
1507 INITCOMMONCONTROLSEX icex;
1508
1509 if (ignore)
1510 return S_OK;
1511
1512 icex.dwSize = sizeof(icex);
1513 icex.dwICC = ICC_LINK_CLASS;
1514
1515 if (!InitCommonControlsEx(&icex))
1516 MessageBoxW(NULL, L"InitCommonControlsEx failed", L"Error", MB_ICONERROR);
1517
1518 psp.dwSize = sizeof(psp);
1519 psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE;
1520 psp.hInstance = module;
1521 psp.pszTemplate = MAKEINTRESOURCE(IDD_VOL_PROP_SHEET);
1522 psp.hIcon = 0;
1523 psp.pszTitle = MAKEINTRESOURCE(IDS_VOL_PROP_SHEET_TITLE);
1524 psp.pfnDlgProc = (DLGPROC)PropSheetDlgProc;
1525 psp.pcRefParent = (UINT*)&objs_loaded;
1526 psp.pfnCallback = NULL;
1527 psp.lParam = (LPARAM)this;
1528
1529 hPage = CreatePropertySheetPage(&psp);
1530
1531 if (hPage) {
1532 if (pfnAddPage(hPage, lParam)) {
1533 this->AddRef();
1534 return S_OK;
1535 } else
1536 DestroyPropertySheetPage(hPage);
1537 } else
1538 return E_OUTOFMEMORY;
1539
1540 return E_FAIL;
1541 }
1542
1543 HRESULT __stdcall BtrfsVolPropSheet::ReplacePage(UINT uPageID, LPFNADDPROPSHEETPAGE pfnReplacePage, LPARAM lParam) {
1544 return S_OK;
1545 }
1546
1547 #ifdef __cplusplus
1548 extern "C" {
1549 #endif
1550
1551 void CALLBACK ResetStatsW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
1552 HANDLE token, h;
1553 NTSTATUS Status;
1554 TOKEN_PRIVILEGES tp;
1555 LUID luid;
1556 UINT64 devid;
1557 WCHAR *s, *vol, *dev;
1558 IO_STATUS_BLOCK iosb;
1559
1560 set_dpi_aware();
1561
1562 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token)) {
1563 ShowError(hwnd, GetLastError());
1564 return;
1565 }
1566
1567 if (!LookupPrivilegeValueW(NULL, L"SeManageVolumePrivilege", &luid)) {
1568 ShowError(hwnd, GetLastError());
1569 goto end;
1570 }
1571
1572 tp.PrivilegeCount = 1;
1573 tp.Privileges[0].Luid = luid;
1574 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1575
1576 if (!AdjustTokenPrivileges(token, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL)) {
1577 ShowError(hwnd, GetLastError());
1578 goto end;
1579 }
1580
1581 s = wcsstr(lpszCmdLine, L"|");
1582 if (!s)
1583 goto end;
1584
1585 s[0] = 0;
1586
1587 vol = lpszCmdLine;
1588 dev = &s[1];
1589
1590 devid = _wtoi(dev);
1591 if (devid == 0)
1592 goto end;
1593
1594 h = CreateFileW(vol, FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
1595 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
1596
1597 if (h == INVALID_HANDLE_VALUE) {
1598 ShowError(hwnd, GetLastError());
1599 goto end;
1600 }
1601
1602 Status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_BTRFS_RESET_STATS, &devid, sizeof(UINT64), NULL, 0);
1603 if (!NT_SUCCESS(Status)) {
1604 ShowNtStatusError(hwnd, Status);
1605
1606 CloseHandle(h);
1607 goto end;
1608 }
1609
1610 CloseHandle(h);
1611
1612 end:
1613 CloseHandle(token);
1614 }
1615
1616 #ifdef __cplusplus
1617 }
1618 #endif