#endif
#endif // __REACTOS__
+#ifdef __REACTOS__
+#define malloc(size) RtlAllocateHeap(RtlGetProcessHeap(), 0, (size))
+#define free(ptr) RtlFreeHeap(RtlGetProcessHeap(), 0, (ptr))
+#endif
+
#define SHA256_HASH_SIZE 32
void calc_sha256(uint8_t* hash, const void* input, size_t len);
static btrfs_root* add_root(LIST_ENTRY* roots, uint64_t id) {
btrfs_root* root;
-#ifdef __REACTOS__
- root = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(btrfs_root));
-#else
root = malloc(sizeof(btrfs_root));
-#endif
root->id = id;
-#ifndef __REACTOS__
RtlZeroMemory(&root->header, sizeof(tree_header));
-#endif
InitializeListHead(&root->items);
InsertTailList(roots, &root->list_entry);
btrfs_item* item = CONTAINING_RECORD(le3, btrfs_item, list_entry);
if (item->data)
-#ifdef __REACTOS__
- RtlFreeHeap(RtlGetProcessHeap(), 0, item->data);
-
- RtlFreeHeap(RtlGetProcessHeap(), 0, item);
-#else
free(item->data);
free(item);
-#endif
le3 = le4;
}
-#ifdef __REACTOS__
- RtlFreeHeap(RtlGetProcessHeap(), 0, r);
-#else
free(r);
-#endif
le = le2;
}
LIST_ENTRY *le2 = le->Flink;
btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry);
-#ifndef __REACTOS__
free(c->chunk_item);
free(c);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, c->chunk_item);
- RtlFreeHeap(RtlGetProcessHeap(), 0, c);
-#endif
le = le2;
}
LIST_ENTRY* le;
btrfs_item* item;
-#ifndef __REACTOS__
item = malloc(sizeof(btrfs_item));
-#else
- item = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(btrfs_item));
-#endif
item->key.obj_id = obj_id;
item->key.obj_type = obj_type;
if (size == 0)
item->data = NULL;
else {
-#ifndef __REACTOS__
item->data = malloc(size);
-#else
- item->data = RtlAllocateHeap(RtlGetProcessHeap(), 0, size);
-#endif
memcpy(item->data, data, size);
}
if (dev->dev_item.num_bytes - dev->dev_item.bytes_used < stripes * size) // not enough space
return NULL;
-#ifndef __REACTOS__
c = malloc(sizeof(btrfs_chunk));
-#else
- c = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(btrfs_chunk));
-#endif
c->offset = off;
c->lastoff = off;
c->used = 0;
-#ifndef __REACTOS__
c->chunk_item = malloc(sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
-#else
- c->chunk_item = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE)));
-#endif
c->chunk_item->size = size;
c->chunk_item->root_id = BTRFS_ROOT_EXTENT;
NTSTATUS Status;
uint8_t* tree;
-#ifndef __REACTOS__
tree = malloc(node_size);
-#else
- tree = RtlAllocateHeap(RtlGetProcessHeap(), 0, node_size);
-#endif
le = roots->Flink;
while (le != roots) {
Status = write_data(h, r->header.address, r->c, tree, node_size);
if (!NT_SUCCESS(Status)) {
-#ifndef __REACTOS__
free(tree);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, tree);
-#endif
return Status;
}
le = le->Flink;
}
-#ifndef __REACTOS__
free(tree);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, tree);
-#endif
return STATUS_SUCCESS;
}
le = le->Flink;
}
-#ifndef __REACTOS__
sb = malloc(sblen);
memset(sb, 0, sblen);
-#else
- sb = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sblen);
-#endif
sb->uuid = *fsuuid;
sb->flags = 1;
for (unsigned int i = 0; i < label->Length / sizeof(WCHAR); i++) {
#endif
if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') {
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return STATUS_INVALID_VOLUME_LABEL;
}
}
}
if (WideCharToMultiByte(CP_UTF8, 0, label->Buffer, label->Length / sizeof(WCHAR), sb->label, utf8len, NULL, NULL) == 0) {
- free(sb);
- return STATUS_INVALID_VOLUME_LABEL;
- }
#else
as.Buffer = sb->label;
as.Length = 0;
if (!NT_SUCCESS(RtlUnicodeStringToAnsiString(&as, label, FALSE)))
{
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
+#endif
+ free(sb);
return STATUS_INVALID_VOLUME_LABEL;
}
-#endif
}
sb->cache_generation = 0xffffffffffffffff;
Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
if (!NT_SUCCESS(Status)) {
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return Status;
}
i++;
}
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return STATUS_SUCCESS;
}
static void add_inode_ref(btrfs_root* r, uint64_t inode, uint64_t parent, uint64_t index, const char* name) {
uint16_t name_len = (uint16_t)strlen(name);
-#ifndef __REACTOS__
INODE_REF* ir = malloc(offsetof(INODE_REF, name[0]) + name_len);
-#else
- INODE_REF* ir = RtlAllocateHeap(RtlGetProcessHeap(), 0, offsetof(INODE_REF, name[0]) + name_len);
-#endif
ir->index = 0;
ir->n = name_len;
add_item(r, inode, TYPE_INODE_REF, parent, ir, (uint16_t)offsetof(INODE_REF, name[0]) + ir->n);
-#ifndef __REACTOS__
free(ir);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, ir);
-#endif
}
static void init_fs_tree(btrfs_root* r, uint32_t node_size) {
LARGE_INTEGER zero;
uint8_t* mb;
-#ifndef __REACTOS__
mb = malloc(0x100000);
memset(mb, 0, 0x100000);
-#else
- mb = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, 0x100000);
-#endif
zero.QuadPart = 0;
Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, mb, 0x100000, &zero, NULL);
-#ifndef __REACTOS__
free(mb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, mb);
-#endif
return Status;
}
IDENTIFY_DEVICE_DATA* idd;
aptelen = sizeof(ATA_PASS_THROUGH_EX) + 512;
-#ifndef __REACTOS__
apte = malloc(aptelen);
RtlZeroMemory(apte, aptelen);
-#else
- apte = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, aptelen);
-#endif
apte->Length = sizeof(ATA_PASS_THROUGH_EX);
apte->AtaFlags = ATA_FLAGS_DATA_IN;
idd = (IDENTIFY_DEVICE_DATA*)((uint8_t*)apte + sizeof(ATA_PASS_THROUGH_EX));
if (idd->NominalMediaRotationRate == 1) {
-#ifndef __REACTOS__
free(apte);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, apte);
-#endif
return true;
}
}
-#ifndef __REACTOS__
free(apte);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, apte);
-#endif
return false;
}
static void add_dir_item(btrfs_root* root, uint64_t inode, uint32_t hash, uint64_t key_objid, uint8_t key_type,
uint64_t key_offset, uint64_t transid, uint8_t type, const char* name) {
uint16_t name_len = (uint16_t)strlen(name);
-#ifndef __REACTOS__
DIR_ITEM* di = malloc(offsetof(DIR_ITEM, name[0]) + name_len);
-#else
- DIR_ITEM* di = RtlAllocateHeap(RtlGetProcessHeap(), 0, offsetof(DIR_ITEM, name[0]) + name_len);
-#endif
di->key.obj_id = key_objid;
di->key.obj_type = key_type;
add_item(root, inode, TYPE_DIR_ITEM, hash, di, (uint16_t)(offsetof(DIR_ITEM, name[0]) + di->m + di->n));
-#ifndef __REACTOS__
free(di);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, di);
-#endif
}
static void set_default_subvol(btrfs_root* root_root, uint32_t node_size) {
if (sblen & (sector_size - 1))
sblen = (sblen & sector_size) + sector_size;
-#ifndef __REACTOS__
sb = malloc(sblen);
-#else
- sb = RtlAllocateHeap(RtlGetProcessHeap(), 0, sblen);
-#endif
off.QuadPart = superblock_addrs[0];
Status = NtReadFile(h, NULL, NULL, NULL, &iosb, sb, sblen, &off, NULL);
if (!NT_SUCCESS(Status)) {
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return false;
}
if (sb->magic != BTRFS_MAGIC) {
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return false;
}
if (!check_superblock_checksum(sb)) {
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
return false;
}
fsuuid = sb->uuid;
devuuid = sb->dev_item.device_uuid;
-#ifndef __REACTOS__
free(sb);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, sb);
-#endif
us.Length = us.MaximumLength = (USHORT)(wcslen(btrfs) * sizeof(WCHAR));
us.Buffer = btrfs;
do {
bfssize += 1024;
-#ifndef __REACTOS__
if (bfs) free(bfs);
bfs = malloc(bfssize);
-#else
- if (bfs) RtlFreeHeap(RtlGetProcessHeap(), 0, bfs);
- bfs = RtlAllocateHeap(RtlGetProcessHeap(), 0, bfssize);
-#endif
Status = NtDeviceIoControlFile(h2, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_QUERY_FILESYSTEMS, NULL, 0, bfs, bfssize);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
+#ifdef __REACTOS__
+ if (bfs) free(bfs);
+#endif
NtClose(h2);
return false;
}
NtClose(h2);
if (bfs)
-#ifndef __REACTOS__
free(bfs);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, bfs);
-#endif
return ret;
}
ULONG mdnsize;
mdnsize = (ULONG)(offsetof(MOUNTDEV_NAME, Name[0]) + DriveRoot->Length);
-#ifndef __REACTOS__
mdn = malloc(mdnsize);
-#else
- mdn = RtlAllocateHeap(RtlGetProcessHeap(), 0, mdnsize);
-#endif
mdn->NameLength = DriveRoot->Length;
memcpy(mdn->Name, DriveRoot->Buffer, DriveRoot->Length);
NtDeviceIoControlFile(btrfsh, NULL, NULL, NULL, &iosb, IOCTL_BTRFS_PROBE_VOLUME, mdn, mdnsize, NULL, 0);
-#ifndef __REACTOS__
free(mdn);
-#else
- RtlFreeHeap(RtlGetProcessHeap(), 0, mdn);
-#endif
NtClose(btrfsh);
}