Ros-diffs January 2017

ros-diffs@reactos.org

15 participants
160 discussions

[pschweitzer] 73513: [UBTRFS] Import the ubtrfs DLL from the BtrFS project. CORE-12617
by pschweitzer＠svn.reactos.org 09 Jan '17

09 Jan '17

Author: pschweitzer Date: Mon Jan 9 20:52:44 2017 New Revision: 73513 URL: http://svn.reactos.org/svn/reactos?rev=73513&view=rev Log: [UBTRFS] Import the ubtrfs DLL from the BtrFS project. CORE-12617 Added: trunk/reactos/dll/win32/ubtrfs/resource.h (with props) Modified: trunk/reactos/dll/win32/ubtrfs/CMakeLists.txt trunk/reactos/dll/win32/ubtrfs/ubtrfs.c trunk/reactos/dll/win32/ubtrfs/ubtrfs.rc trunk/reactos/dll/win32/ubtrfs/ubtrfs.spec trunk/reactos/media/doc/README.FSD Modified: trunk/reactos/dll/win32/ubtrfs/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/ubtrfs/CMakeList… ============================================================================== --- trunk/reactos/dll/win32/ubtrfs/CMakeLists.txt [iso-8859-1] (original) +++ trunk/reactos/dll/win32/ubtrfs/CMakeLists.txt [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -8,6 +8,5 @@ add_library(ubtrfs SHARED ${SOURCE}) set_module_type(ubtrfs nativedll) -target_link_libraries(ubtrfs btrfslib) add_importlibs(ubtrfs ntdll) add_cd_file(TARGET ubtrfs DESTINATION reactos/system32 FOR all) Added: trunk/reactos/dll/win32/ubtrfs/resource.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/ubtrfs/resource.… ============================================================================== --- trunk/reactos/dll/win32/ubtrfs/resource.h (added) +++ trunk/reactos/dll/win32/ubtrfs/resource.h [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -0,0 +1,14 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by ubtrfs.rc + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 101 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif Propchange: trunk/reactos/dll/win32/ubtrfs/resource.h ------------------------------------------------------------------------------ svn:eol-style = native Propchange: trunk/reactos/dll/win32/ubtrfs/resource.h ------------------------------------------------------------------------------ svn:executable = * Modified: trunk/reactos/dll/win32/ubtrfs/ubtrfs.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/ubtrfs/ubtrfs.c?… ============================================================================== --- trunk/reactos/dll/win32/ubtrfs/ubtrfs.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/ubtrfs/ubtrfs.c [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -1,23 +1,1463 @@ -/* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: BTRFS File System Management - * FILE: dll/win32/ubtrfs/ubtrfs.c - * PURPOSE: ubtrfs DLL initialisation - * - * PROGRAMMERS: Pierre Schweitzer - */ - +/* Copyright (c) Mark Harmstone 2016 + * + * This file is part of WinBtrfs. + * + * WinBtrfs is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public Licence as published by + * the Free Software Foundation, either version 3 of the Licence, or + * (at your option) any later version. + * + * WinBtrfs is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public Licence for more details. + * + * You should have received a copy of the GNU Lesser General Public Licence + * along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */ + +#include <stdlib.h> +#include <stddef.h> +#include <time.h> +#include <ntstatus.h> +#define WIN32_NO_STATUS #include <windef.h> - -INT WINAPI -DllMain( - IN HINSTANCE hinstDLL, - IN DWORD dwReason, - IN LPVOID lpvReserved) +#include <winbase.h> +#ifndef __REACTOS__ +#include <winternl.h> +#include <devioctl.h> +#include <ntdddisk.h> +#else +#include <ndk/iofuncs.h> +#include <ndk/obfuncs.h> +#include <ndk/rtlfuncs.h> +#endif +#include <ntddscsi.h> +#include <ata.h> +#include <mountmgr.h> +#ifdef __REACTOS__ +#include "../../drivers/filesystems/btrfs/btrfs.h" +#include "../../drivers/filesystems/btrfs/btrfsioctl.h" +#else +#include "../btrfs.h" +#include "../btrfsioctl.h" +#endif + +#ifndef __REACTOS__ +#define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSCTL_UNLOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSCTL_DISMOUNT_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS) +#endif + +#ifndef __REACTOS__ +#ifdef __cplusplus +extern "C" { +#endif +NTSYSCALLAPI NTSTATUS NTAPI NtFsControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength); + +NTSTATUS NTAPI NtWriteFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, + ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key); + +NTSTATUS NTAPI NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, + ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key); + +NTSYSAPI NTSTATUS NTAPI RtlUnicodeToUTF8N(PCHAR UTF8StringDestination, ULONG UTF8StringMaxByteCount, PULONG UTF8StringActualByteCount, + PCWCH UnicodeStringSource, ULONG UnicodeStringByteCount); +#ifdef __cplusplus +} +#endif + +FORCEINLINE VOID InitializeListHead(PLIST_ENTRY ListHead) { + ListHead->Flink = ListHead->Blink = ListHead; +} + +FORCEINLINE VOID InsertTailList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry) { + PLIST_ENTRY Blink; + + Blink = ListHead->Blink; + Entry->Flink = ListHead; + Entry->Blink = Blink; + Blink->Flink = Entry; + ListHead->Blink = Entry; +} +#endif + +#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7) +NTSTATUS WINAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max, + ULONG *utf8_bytes_written, + const WCHAR *uni_src, ULONG uni_bytes); +#endif /* defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7) */ + +#ifdef __REACTOS__ +ULONG WINAPI NtGetTickCount(VOID); +#endif + +typedef struct { + KEY key; + UINT16 size; + void* data; + LIST_ENTRY list_entry; +} btrfs_item; + +typedef struct { + UINT64 offset; + CHUNK_ITEM* chunk_item; + UINT64 lastoff; + UINT64 used; + LIST_ENTRY list_entry; +} btrfs_chunk; + +typedef struct { + UINT64 id; + tree_header header; + btrfs_chunk* c; + LIST_ENTRY items; + LIST_ENTRY list_entry; +} btrfs_root; + +typedef struct { + DEV_ITEM dev_item; + UINT64 last_alloc; +} btrfs_dev; + +#define keycmp(key1, key2)\ + ((key1.obj_id < key2.obj_id) ? -1 :\ + ((key1.obj_id > key2.obj_id) ? 1 :\ + ((key1.obj_type < key2.obj_type) ? -1 :\ + ((key1.obj_type > key2.obj_type) ? 1 :\ + ((key1.offset < key2.offset) ? -1 :\ + ((key1.offset > key2.offset) ? 1 :\ + 0)))))) + +HMODULE module; + +// the following definitions come from fmifs.h in ReactOS + +typedef struct { + ULONG Lines; + PCHAR Output; +} TEXTOUTPUT, *PTEXTOUTPUT; + +typedef enum { + FMIFS_UNKNOWN0, + FMIFS_UNKNOWN1, + FMIFS_UNKNOWN2, + FMIFS_UNKNOWN3, + FMIFS_UNKNOWN4, + FMIFS_UNKNOWN5, + FMIFS_UNKNOWN6, + FMIFS_UNKNOWN7, + FMIFS_FLOPPY, + FMIFS_UNKNOWN9, + FMIFS_UNKNOWN10, + FMIFS_REMOVABLE, + FMIFS_HARDDISK, + FMIFS_UNKNOWN13, + FMIFS_UNKNOWN14, + FMIFS_UNKNOWN15, + FMIFS_UNKNOWN16, + FMIFS_UNKNOWN17, + FMIFS_UNKNOWN18, + FMIFS_UNKNOWN19, + FMIFS_UNKNOWN20, + FMIFS_UNKNOWN21, + FMIFS_UNKNOWN22, + FMIFS_UNKNOWN23, +} FMIFS_MEDIA_FLAG; + +typedef enum { + PROGRESS, + DONEWITHSTRUCTURE, + UNKNOWN2, + UNKNOWN3, + UNKNOWN4, + UNKNOWN5, + INSUFFICIENTRIGHTS, + FSNOTSUPPORTED, + VOLUMEINUSE, + UNKNOWN9, + UNKNOWNA, + DONE, + UNKNOWNC, + UNKNOWND, + OUTPUT, + STRUCTUREPROGRESS, + CLUSTERSIZETOOSMALL, +} CALLBACKCOMMAND; + +typedef BOOLEAN (NTAPI* PFMIFSCALLBACK)(CALLBACKCOMMAND Command, ULONG SubAction, PVOID ActionInfo); + +static const UINT32 crctable[] = { + 0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb, + 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, + 0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384, + 0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b, + 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a, 0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, + 0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa, + 0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a, + 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595, + 0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957, + 0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198, + 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, + 0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7, + 0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789, + 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, + 0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6, + 0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829, + 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93, + 0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c, + 0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc, + 0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, + 0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d, + 0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982, + 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d, 0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622, + 0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed, + 0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f, + 0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0, + 0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540, + 0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f, + 0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1, + 0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e, + 0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e, + 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351, +}; + +static UINT32 calc_crc32c(UINT32 seed, UINT8* msg, ULONG msglen) { + UINT32 rem; + ULONG i; + + rem = seed; + + for (i = 0; i < msglen; i++) { + rem = crctable[(rem ^ msg[i]) & 0xff] ^ (rem >> 8); + } + + return rem; +} + +NTSTATUS WINAPI ChkdskEx(PUNICODE_STRING DriveRoot, BOOLEAN FixErrors, BOOLEAN Verbose, BOOLEAN CheckOnlyIfDirty, + BOOLEAN ScanDrive, PFMIFSCALLBACK Callback) { + // STUB + + if (Callback) { + TEXTOUTPUT TextOut; + + TextOut.Lines = 1; + TextOut.Output = "stub, not implemented"; + + Callback(OUTPUT, 0, &TextOut); + } + + return STATUS_SUCCESS; +} + +static btrfs_root* add_root(LIST_ENTRY* roots, UINT64 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); + + return root; +} + +static void free_roots(LIST_ENTRY* roots) { + LIST_ENTRY* le; + + le = roots->Flink; + while (le != roots) { + LIST_ENTRY *le2 = le->Flink, *le3; + btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry); + + le3 = r->items.Flink; + while (le3 != &r->items) { + LIST_ENTRY* le4 = le3->Flink; + 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; + } +} + +static void free_chunks(LIST_ENTRY* chunks) { + LIST_ENTRY* le; + + le = chunks->Flink; + while (le != chunks) { + 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; + } +} + +static void add_item(btrfs_root* r, UINT64 obj_id, UINT8 obj_type, UINT64 offset, void* data, UINT16 size) { + 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; + item->key.offset = offset; + item->size = size; + + 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); + } + + le = r->items.Flink; + while (le != &r->items) { + btrfs_item* i2 = CONTAINING_RECORD(le, btrfs_item, list_entry); + + if (keycmp(item->key, i2->key) != 1) { + InsertTailList(le, &item->list_entry); + return; + } + + le = le->Flink; + } + + InsertTailList(&r->items, &item->list_entry); +} + +static UINT64 find_chunk_offset(UINT64 size, UINT64 offset, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid) { + UINT64 off; + DEV_EXTENT de; + + off = dev->last_alloc; + dev->last_alloc += size; + + dev->dev_item.bytes_used += size; + + de.chunktree = BTRFS_ROOT_CHUNK; + de.objid = 0x100; + de.address = offset; + de.length = size; + de.chunktree_uuid = *chunkuuid; + + add_item(dev_root, dev->dev_item.dev_id, TYPE_DEV_EXTENT, off, &de, sizeof(DEV_EXTENT)); + + return off; +} + +static btrfs_chunk* add_chunk(LIST_ENTRY* chunks, UINT64 flags, btrfs_root* chunk_root, btrfs_dev* dev, btrfs_root* dev_root, BTRFS_UUID* chunkuuid, UINT32 sector_size) { + UINT64 off, size; + UINT16 stripes, i; + btrfs_chunk* c; + LIST_ENTRY* le; + CHUNK_ITEM_STRIPE* cis; + + off = 0xc00000; + le = chunks->Flink; + while (le != chunks) { + c = CONTAINING_RECORD(le, btrfs_chunk, list_entry); + + if (c->offset + c->chunk_item->size > off) + off = c->offset + c->chunk_item->size; + + le = le->Flink; + } + + if (flags & BLOCK_FLAG_METADATA) { + if (dev->dev_item.num_bytes > 0xC80000000) // 50 GB + size = 0x40000000; // 1 GB + else + size = 0x10000000; // 256 MB + } else if (flags & BLOCK_FLAG_SYSTEM) + size = 0x800000; + + size = min(size, dev->dev_item.num_bytes / 10); // cap at 10% + size &= ~(sector_size - 1); + + stripes = flags & BLOCK_FLAG_DUPLICATE ? 2 : 1; + + 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; + c->chunk_item->stripe_length = 0x10000; + c->chunk_item->type = flags; + c->chunk_item->opt_io_alignment = 0x10000; + c->chunk_item->opt_io_width = 0x10000; + c->chunk_item->sector_size = sector_size; + c->chunk_item->num_stripes = stripes; + c->chunk_item->sub_stripes = 0; + + cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1]; + + for (i = 0; i < stripes; i++) { + cis[i].dev_id = dev->dev_item.dev_id; + cis[i].offset = find_chunk_offset(size, c->offset, dev, dev_root, chunkuuid); + cis[i].dev_uuid = dev->dev_item.device_uuid; + } + + add_item(chunk_root, 0x100, TYPE_CHUNK_ITEM, c->offset, c->chunk_item, sizeof(CHUNK_ITEM) + (stripes * sizeof(CHUNK_ITEM_STRIPE))); + + InsertTailList(chunks, &c->list_entry); + + return c; +} + +static BOOL superblock_collision(btrfs_chunk* c, UINT64 address) { + CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1]; + UINT64 stripe = (address - c->offset) / c->chunk_item->stripe_length; + UINT16 i, j; + + for (i = 0; i < c->chunk_item->num_stripes; i++) { + j = 0; + while (superblock_addrs[j] != 0) { + if (superblock_addrs[j] >= cis[i].offset) { + UINT64 stripe2 = (superblock_addrs[j] - cis[i].offset) / c->chunk_item->stripe_length; + + if (stripe2 == stripe) + return TRUE; + } + j++; + } + } + + return FALSE; +} + +static UINT64 get_next_address(btrfs_chunk* c) { + UINT64 addr; + + addr = c->lastoff; + + while (superblock_collision(c, addr)) { + addr = addr - ((addr - c->offset) % c->chunk_item->stripe_length) + c->chunk_item->stripe_length; + + if (addr >= c->offset + c->chunk_item->size) // chunk has been exhausted + return 0; + } + + return addr; +} + +typedef struct { + EXTENT_ITEM ei; + UINT8 type; + TREE_BLOCK_REF tbr; +} EXTENT_ITEM_METADATA; + +static void assign_addresses(LIST_ENTRY* roots, btrfs_chunk* sys_chunk, btrfs_chunk* metadata_chunk, UINT32 node_size, + btrfs_root* root_root, btrfs_root* extent_root) { + LIST_ENTRY* le; + + le = roots->Flink; + while (le != roots) { + btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry); + btrfs_chunk* c = r->id == BTRFS_ROOT_CHUNK ? sys_chunk : metadata_chunk; + EXTENT_ITEM_METADATA eim; + + r->header.address = get_next_address(c); + r->c = c; + c->lastoff = r->header.address + node_size; + c->used += node_size; + + eim.ei.refcount = 1; + eim.ei.generation = 1; + eim.ei.flags = EXTENT_ITEM_TREE_BLOCK; + eim.type = TYPE_TREE_BLOCK_REF; + eim.tbr.offset = r->id; + + // FIXME - support non-skinny EXTENT_ITEM + add_item(extent_root, r->header.address, TYPE_METADATA_ITEM, 0, &eim, sizeof(EXTENT_ITEM_METADATA)); + + if (r->id != BTRFS_ROOT_ROOT && r->id != BTRFS_ROOT_CHUNK) { + ROOT_ITEM ri; + + memset(&ri, 0, sizeof(ROOT_ITEM)); + + ri.inode.generation = 1; + ri.inode.st_size = 3; + ri.inode.st_blocks = node_size; + ri.inode.st_nlink = 1; + ri.inode.st_mode = 040755; + ri.generation = 1; + ri.objid = r->id == 5 || r->id >= 0x100 ? SUBVOL_ROOT_INODE : 0; + ri.block_number = r->header.address; + ri.bytes_used = node_size; + ri.num_references = 1; + ri.generation2 = ri.generation; + + add_item(root_root, r->id, TYPE_ROOT_ITEM, 0, &ri, sizeof(ROOT_ITEM)); + } + + le = le->Flink; + } +} + +static NTSTATUS write_data(HANDLE h, UINT64 address, btrfs_chunk* c, void* data, ULONG size) { + NTSTATUS Status; + UINT16 i; + IO_STATUS_BLOCK iosb; + LARGE_INTEGER off; + CHUNK_ITEM_STRIPE* cis; + + cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1]; + + for (i = 0; i < c->chunk_item->num_stripes; i++) { + off.QuadPart = cis[i].offset + address - c->offset; + + Status = NtWriteFile(h, NULL, NULL, NULL, &iosb, data, size, &off, NULL); + if (!NT_SUCCESS(Status)) + return Status; + } + + return STATUS_SUCCESS; +} + +static NTSTATUS write_roots(HANDLE h, LIST_ENTRY* roots, UINT32 node_size, BTRFS_UUID* fsuuid, BTRFS_UUID* chunkuuid) { + LIST_ENTRY *le, *le2; + NTSTATUS Status; + UINT8* tree; + +#ifndef __REACTOS__ + tree = malloc(node_size); +#else + tree = RtlAllocateHeap(RtlGetProcessHeap(), 0, node_size); +#endif + + le = roots->Flink; + while (le != roots) { + btrfs_root* r = CONTAINING_RECORD(le, btrfs_root, list_entry); + UINT8* dp; + leaf_node* ln; + UINT32 crc32; + + memset(tree, 0, node_size); + + r->header.num_items = 0; + r->header.fs_uuid = *fsuuid; + r->header.flags = HEADER_FLAG_MIXED_BACKREF | HEADER_FLAG_WRITTEN; + r->header.chunk_tree_uuid = *chunkuuid; + r->header.generation = 1; + r->header.tree_id = r->id; + + ln = (leaf_node*)(tree + sizeof(tree_header)); + + dp = tree + node_size; + + le2 = r->items.Flink; + while (le2 != &r->items) { + btrfs_item* item = CONTAINING_RECORD(le2, btrfs_item, list_entry); + + ln->key = item->key; + ln->size = item->size; + + if (item->size > 0) { + dp -= item->size; + memcpy(dp, item->data, item->size); + + ln->offset = dp - tree - sizeof(tree_header); + } else + ln->offset = 0; + + ln = &ln[1]; + + r->header.num_items++; + + le2 = le2->Flink; + } + + memcpy(tree, &r->header, sizeof(tree_header)); + + crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&((tree_header*)tree)->fs_uuid, node_size - sizeof(((tree_header*)tree)->csum)); + memcpy(tree, &crc32, sizeof(UINT32)); + + 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; +} + +#ifndef __REACTOS__ +static void get_uuid(BTRFS_UUID* uuid) { +#else +static void get_uuid(BTRFS_UUID* uuid, ULONG* seed) { +#endif + UINT8 i; + + for (i = 0; i < 16; i+=2) { +#ifndef __REACTOS__ + ULONG r = rand(); +#else + ULONG r = RtlRandom(seed); +#endif + + uuid->uuid[i] = (r & 0xff00) >> 8; + uuid->uuid[i+1] = r & 0xff; + } +} + +#ifndef __REACTOS__ +static void init_device(btrfs_dev* dev, UINT64 id, UINT64 size, BTRFS_UUID* fsuuid, UINT32 sector_size) { +#else +static void init_device(btrfs_dev* dev, UINT64 id, UINT64 size, BTRFS_UUID* fsuuid, UINT32 sector_size, ULONG* seed) { +#endif + dev->dev_item.dev_id = id; + dev->dev_item.num_bytes = size; + dev->dev_item.bytes_used = 0; + dev->dev_item.optimal_io_align = sector_size; + dev->dev_item.optimal_io_width = sector_size; + dev->dev_item.minimal_io_size = sector_size; + dev->dev_item.type = 0; + dev->dev_item.generation = 0; + dev->dev_item.start_offset = 0; + dev->dev_item.dev_group = 0; + dev->dev_item.seek_speed = 0; + dev->dev_item.bandwidth = 0; +#ifndef __REACTOS__ + get_uuid(&dev->dev_item.device_uuid); +#else + get_uuid(&dev->dev_item.device_uuid, seed); +#endif + dev->dev_item.fs_uuid = *fsuuid; + + dev->last_alloc = 0x100000; // skip first megabyte +} + +#ifdef __REACTOS__ +NTSTATUS NTAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max, + ULONG *utf8_bytes_written, + const WCHAR *uni_src, ULONG uni_bytes) { - UNREFERENCED_PARAMETER(hinstDLL); - UNREFERENCED_PARAMETER(dwReason); - UNREFERENCED_PARAMETER(lpvReserved); - - return TRUE; -} + NTSTATUS status; + ULONG i; + ULONG written; + ULONG ch; + BYTE utf8_ch[4]; + ULONG utf8_ch_len; + + if (!uni_src) + return STATUS_INVALID_PARAMETER_4; + if (!utf8_bytes_written) + return STATUS_INVALID_PARAMETER; + if (utf8_dest && uni_bytes % sizeof(WCHAR)) + return STATUS_INVALID_PARAMETER_5; + + written = 0; + status = STATUS_SUCCESS; + + for (i = 0; i < uni_bytes / sizeof(WCHAR); i++) + { + /* decode UTF-16 into ch */ + ch = uni_src[i]; + if (ch >= 0xdc00 && ch <= 0xdfff) + { + ch = 0xfffd; + status = STATUS_SOME_NOT_MAPPED; + } + else if (ch >= 0xd800 && ch <= 0xdbff) + { + if (i + 1 < uni_bytes / sizeof(WCHAR)) + { + ch -= 0xd800; + ch <<= 10; + if (uni_src[i + 1] >= 0xdc00 && uni_src[i + 1] <= 0xdfff) + { + ch |= uni_src[i + 1] - 0xdc00; + ch += 0x010000; + i++; + } + else + { + ch = 0xfffd; + status = STATUS_SOME_NOT_MAPPED; + } + } + else + { + ch = 0xfffd; + status = STATUS_SOME_NOT_MAPPED; + } + } + + /* encode ch as UTF-8 */ + ASSERT(ch <= 0x10ffff); + if (ch < 0x80) + { + utf8_ch[0] = ch & 0x7f; + utf8_ch_len = 1; + } + else if (ch < 0x800) + { + utf8_ch[0] = 0xc0 | (ch >> 6 & 0x1f); + utf8_ch[1] = 0x80 | (ch >> 0 & 0x3f); + utf8_ch_len = 2; + } + else if (ch < 0x10000) + { + utf8_ch[0] = 0xe0 | (ch >> 12 & 0x0f); + utf8_ch[1] = 0x80 | (ch >> 6 & 0x3f); + utf8_ch[2] = 0x80 | (ch >> 0 & 0x3f); + utf8_ch_len = 3; + } + else if (ch < 0x200000) + { + utf8_ch[0] = 0xf0 | (ch >> 18 & 0x07); + utf8_ch[1] = 0x80 | (ch >> 12 & 0x3f); + utf8_ch[2] = 0x80 | (ch >> 6 & 0x3f); + utf8_ch[3] = 0x80 | (ch >> 0 & 0x3f); + utf8_ch_len = 4; + } + + if (!utf8_dest) + { + written += utf8_ch_len; + continue; + } + + if (utf8_bytes_max >= utf8_ch_len) + { + memcpy(utf8_dest, utf8_ch, utf8_ch_len); + utf8_dest += utf8_ch_len; + utf8_bytes_max -= utf8_ch_len; + written += utf8_ch_len; + } + else + { + utf8_bytes_max = 0; + status = STATUS_BUFFER_TOO_SMALL; + } + } + + *utf8_bytes_written = written; + return status; +} +#endif + +static NTSTATUS write_superblocks(HANDLE h, btrfs_dev* dev, btrfs_root* chunk_root, btrfs_root* root_root, btrfs_root* extent_root, + btrfs_chunk* sys_chunk, UINT32 node_size, BTRFS_UUID* fsuuid, UINT32 sector_size, PUNICODE_STRING label) { + NTSTATUS Status; + IO_STATUS_BLOCK iosb; + ULONG sblen; + int i; + UINT32 crc32; + superblock* sb; + KEY* key; + UINT64 bytes_used; + LIST_ENTRY* le; + + sblen = sizeof(sb); + if (sblen & (sector_size - 1)) + sblen = (sblen & sector_size) + sector_size; + + bytes_used = 0; + + le = extent_root->items.Flink; + while (le != &extent_root->items) { + btrfs_item* item = CONTAINING_RECORD(le, btrfs_item, list_entry); + + if (item->key.obj_type == TYPE_EXTENT_ITEM) + bytes_used += item->key.offset; + else if (item->key.obj_type == TYPE_METADATA_ITEM) + bytes_used += node_size; + + 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; + sb->magic = BTRFS_MAGIC; + sb->generation = 1; + sb->root_tree_addr = root_root->header.address; + sb->chunk_tree_addr = chunk_root->header.address; + sb->total_bytes = dev->dev_item.num_bytes; + sb->bytes_used = bytes_used; + sb->root_dir_objectid = 6; + sb->num_devices = 1; + sb->sector_size = sector_size; + sb->node_size = node_size; + sb->leaf_size = node_size; + sb->stripe_size = sector_size; + sb->n = sizeof(KEY) + sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE)); + sb->chunk_root_generation = 1; + sb->incompat_flags = BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF | BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA; + memcpy(&sb->dev_item, &dev->dev_item, sizeof(DEV_ITEM)); + + if (label->Length > 0) { + int i; + ULONG utf8len; + + for (i = 0; i < label->Length / sizeof(WCHAR); i++) { + if (label->Buffer[i] == '/' || label->Buffer[i] == '\\') { +#ifndef __REACTOS__ + free(sb); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, sb); +#endif + return STATUS_INVALID_VOLUME_LABEL; + } + } + + Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, label->Buffer, label->Length); + if (!NT_SUCCESS(Status)) { +#ifndef __REACTOS__ + free(sb); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, sb); +#endif + return Status; + } + + if (utf8len > MAX_LABEL_SIZE) { +#ifndef __REACTOS__ + free(sb); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, sb); +#endif + return STATUS_INVALID_VOLUME_LABEL; + } + + Status = RtlUnicodeToUTF8N((PCHAR)&sb->label, MAX_LABEL_SIZE, &utf8len, label->Buffer, label->Length); + if (!NT_SUCCESS(Status)) { +#ifndef __REACTOS__ + free(sb); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, sb); +#endif + return Status; + } + } + sb->cache_generation = 0xffffffffffffffff; + + key = (KEY*)sb->sys_chunk_array; + key->obj_id = 0x100; + key->obj_type = TYPE_CHUNK_ITEM; + key->offset = sys_chunk->offset; + memcpy(&key[1], sys_chunk->chunk_item, sizeof(CHUNK_ITEM) + (sys_chunk->chunk_item->num_stripes * sizeof(CHUNK_ITEM_STRIPE))); + + i = 0; + while (superblock_addrs[i] != 0) { + LARGE_INTEGER off; + + if (superblock_addrs[i] > dev->dev_item.num_bytes) + break; + + sb->sb_phys_addr = superblock_addrs[i]; + + crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum)); + memcpy(&sb->checksum, &crc32, sizeof(UINT32)); + + off.QuadPart = superblock_addrs[i]; + + 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 __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME* out) { + ULONGLONG l = t.QuadPart - 116444736000000000; + + out->seconds = l / 10000000; + out->nanoseconds = (l % 10000000) * 100; +} + +#ifdef __REACTOS__ +VOID +WINAPI +GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime) +{ + LARGE_INTEGER SystemTime; + + do + { + SystemTime.HighPart = SharedUserData->SystemTime.High1Time; + SystemTime.LowPart = SharedUserData->SystemTime.LowPart; + } + while (SystemTime.HighPart != SharedUserData->SystemTime.High2Time); + + lpFileTime->dwLowDateTime = SystemTime.LowPart; + lpFileTime->dwHighDateTime = SystemTime.HighPart; +} +#endif + +static void init_fs_tree(btrfs_root* r, UINT32 node_size) { + INODE_ITEM ii; + INODE_REF* ir; +#ifndef __REACTOS__ + SYSTEMTIME systime; +#endif + FILETIME filetime; + LARGE_INTEGER time; + + memset(&ii, 0, sizeof(INODE_ITEM)); + + ii.generation = 1; + ii.st_blocks = node_size; + ii.st_nlink = 1; + ii.st_mode = 040755; + +#ifndef __REACTOS__ + GetSystemTime(&systime); + SystemTimeToFileTime(&systime, &filetime); +#else + GetSystemTimeAsFileTime(&filetime); +#endif + time.LowPart = filetime.dwLowDateTime; + time.HighPart = filetime.dwHighDateTime; + + win_time_to_unix(time, &ii.st_atime); + ii.st_ctime = ii.st_mtime = ii.st_atime; + + add_item(r, SUBVOL_ROOT_INODE, TYPE_INODE_ITEM, 0, &ii, sizeof(INODE_ITEM)); + +#ifndef __REACTOS__ + ir = malloc(sizeof(INODE_REF) - 1 + 2); +#else + ir = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(INODE_REF) - 1 + 2); +#endif + + ir->index = 0; + ir->n = 2; + ir->name[0] = '.'; + ir->name[1] = '.'; + + add_item(r, SUBVOL_ROOT_INODE, TYPE_INODE_REF, SUBVOL_ROOT_INODE, ir, sizeof(INODE_REF) - 1 + ir->n); + +#ifndef __REACTOS__ + free(ir); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, ir); +#endif +} + +static void add_block_group_items(LIST_ENTRY* chunks, btrfs_root* extent_root) { + LIST_ENTRY* le; + + le = chunks->Flink; + while (le != chunks) { + btrfs_chunk* c = CONTAINING_RECORD(le, btrfs_chunk, list_entry); + BLOCK_GROUP_ITEM bgi; + + bgi.used = c->used; + bgi.chunk_tree = 0x100; + bgi.flags = c->chunk_item->type; + add_item(extent_root, c->offset, TYPE_BLOCK_GROUP_ITEM, c->chunk_item->size, &bgi, sizeof(BLOCK_GROUP_ITEM)); + + le = le->Flink; + } +} + +static NTSTATUS clear_first_megabyte(HANDLE h) { + NTSTATUS Status; + IO_STATUS_BLOCK iosb; + LARGE_INTEGER zero; + UINT8* mb; + +#ifndef __REACTOS__ + mb = malloc(0x100000); +#else + mb = RtlAllocateHeap(RtlGetProcessHeap(), 0, 0x100000); +#endif + memset(mb, 0, 0x100000); + + 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; +} + +static BOOL is_ssd(HANDLE h) { + ULONG aptelen; + ATA_PASS_THROUGH_EX* apte; + IO_STATUS_BLOCK iosb; + NTSTATUS 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; + apte->DataTransferLength = aptelen - sizeof(ATA_PASS_THROUGH_EX); + apte->TimeOutValue = 3; + apte->DataBufferOffset = apte->Length; + apte->CurrentTaskFile[6] = IDE_COMMAND_IDENTIFY; + + Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_ATA_PASS_THROUGH, apte, aptelen, apte, aptelen); + + if (NT_SUCCESS(Status)) { + idd = (IDENTIFY_DEVICE_DATA*)((UINT8*)apte + sizeof(ATA_PASS_THROUGH_EX)); + + if (idd->NominalMediaRotationRate == 1) + return TRUE; + } + + return FALSE; +} + +static NTSTATUS write_btrfs(HANDLE h, UINT64 size, PUNICODE_STRING label, UINT32 sector_size) { + NTSTATUS Status; + UINT32 node_size; + LIST_ENTRY roots, chunks; + btrfs_root *root_root, *chunk_root, *extent_root, *dev_root, *fs_root, *reloc_root; + btrfs_chunk *sys_chunk, *metadata_chunk; + btrfs_dev dev; + BTRFS_UUID fsuuid, chunkuuid; + BOOL ssd; +#ifdef __REACTOS__ + ULONG seed; +#endif + +#ifndef __REACTOS__ + srand(time(0)); + get_uuid(&fsuuid); + get_uuid(&chunkuuid); +#else + seed = NtGetTickCount(); + get_uuid(&fsuuid, &seed); + get_uuid(&chunkuuid, &seed); +#endif + + InitializeListHead(&roots); + InitializeListHead(&chunks); + + root_root = add_root(&roots, BTRFS_ROOT_ROOT); + chunk_root = add_root(&roots, BTRFS_ROOT_CHUNK); + extent_root = add_root(&roots, BTRFS_ROOT_EXTENT); + dev_root = add_root(&roots, BTRFS_ROOT_DEVTREE); + add_root(&roots, BTRFS_ROOT_CHECKSUM); + fs_root = add_root(&roots, BTRFS_ROOT_FSTREE); + reloc_root = add_root(&roots, BTRFS_ROOT_DATA_RELOC); + +#ifndef __REACTOS__ + init_device(&dev, 1, size, &fsuuid, sector_size); +#else + init_device(&dev, 1, size, &fsuuid, sector_size, &seed); +#endif + + ssd = is_ssd(h); + + sys_chunk = add_chunk(&chunks, BLOCK_FLAG_SYSTEM | (ssd ? 0 : BLOCK_FLAG_DUPLICATE), chunk_root, &dev, dev_root, &chunkuuid, sector_size); + if (!sys_chunk) + return STATUS_INTERNAL_ERROR; + + metadata_chunk = add_chunk(&chunks, BLOCK_FLAG_METADATA | (ssd ? 0 : BLOCK_FLAG_DUPLICATE), chunk_root, &dev, dev_root, &chunkuuid, sector_size); + if (!metadata_chunk) + return STATUS_INTERNAL_ERROR; + + node_size = 0x4000; + assign_addresses(&roots, sys_chunk, metadata_chunk, node_size, root_root, extent_root); + + add_item(chunk_root, 1, TYPE_DEV_ITEM, dev.dev_item.dev_id, &dev.dev_item, sizeof(DEV_ITEM)); + + init_fs_tree(fs_root, node_size); + init_fs_tree(reloc_root, node_size); + + add_block_group_items(&chunks, extent_root); + + Status = write_roots(h, &roots, node_size, &fsuuid, &chunkuuid); + if (!NT_SUCCESS(Status)) + return Status; + + Status = clear_first_megabyte(h); + if (!NT_SUCCESS(Status)) + return Status; + + Status = write_superblocks(h, &dev, chunk_root, root_root, extent_root, sys_chunk, node_size, &fsuuid, sector_size, label); + if (!NT_SUCCESS(Status)) + return Status; + + free_roots(&roots); + free_chunks(&chunks); + + return STATUS_SUCCESS; +} + +static BOOL look_for_device(btrfs_filesystem* bfs, BTRFS_UUID* devuuid) { + UINT32 i; + btrfs_filesystem_device* dev; + + for (i = 0; i < bfs->num_devices; i++) { + if (i == 0) + dev = &bfs->device; + else + dev = (btrfs_filesystem_device*)((UINT8*)dev + offsetof(btrfs_filesystem_device, name[0]) + dev->name_length); + + if (RtlCompareMemory(&dev->uuid, devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) + return TRUE; + } + + return FALSE; +} + +static BOOL is_mounted_multi_device(HANDLE h, UINT32 sector_size) { + NTSTATUS Status; + superblock* sb; + ULONG sblen; + IO_STATUS_BLOCK iosb; + LARGE_INTEGER off; + BTRFS_UUID fsuuid, devuuid; + UINT32 crc32; + UNICODE_STRING us; + OBJECT_ATTRIBUTES atts; + HANDLE h2; + btrfs_filesystem *bfs = NULL, *bfs2; + ULONG bfssize; + BOOL ret = FALSE; + + static WCHAR btrfs[] = L"\\Btrfs"; + + sblen = sizeof(sb); + 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; + } + + crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum)); + if (crc32 != *((UINT32*)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 = wcslen(btrfs) * sizeof(WCHAR); + us.Buffer = btrfs; + + InitializeObjectAttributes(&atts, &us, 0, NULL, NULL); + + Status = NtOpenFile(&h2, SYNCHRONIZE | FILE_READ_ATTRIBUTES, &atts, &iosb, + FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_ALERT); + if (!NT_SUCCESS(Status)) // not a problem, it usually just means the driver isn't loaded + return FALSE; + + bfssize = 0; + + 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) { + NtClose(h2); + return FALSE; + } + } while (Status == STATUS_BUFFER_OVERFLOW); + + if (!NT_SUCCESS(Status)) + goto end; + + if (bfs->num_devices != 0) { + bfs2 = bfs; + while (TRUE) { + if (RtlCompareMemory(&bfs2->uuid, &fsuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) { + if (bfs2->num_devices == 1) + ret = FALSE; + else + ret = look_for_device(bfs2, &devuuid); + + goto end; + } + + if (bfs2->next_entry == 0) + break; + else + bfs2 = (btrfs_filesystem*)((UINT8*)bfs2 + bfs2->next_entry); + } + } + +end: + NtClose(h2); + + if (bfs) +#ifndef __REACTOS__ + free(bfs); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, bfs); +#endif + + return ret; +} + +static void add_drive_letter(HANDLE h) { + NTSTATUS Status; + IO_STATUS_BLOCK iosb; + MOUNTDEV_NAME mdn, *mdn2; + UNICODE_STRING us; + OBJECT_ATTRIBUTES attr; + HANDLE mountmgr; + MOUNTMGR_DRIVE_LETTER_INFORMATION mdli; + + Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(mdn)); + if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) + return; + +#ifndef __REACTOS__ + mdn2 = malloc(offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength); +#else + mdn2 = RtlAllocateHeap(RtlGetProcessHeap(), 0, offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength); +#endif + + Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength); + if (!NT_SUCCESS(Status)) + goto end; + + RtlInitUnicodeString(&us, MOUNTMGR_DEVICE_NAME); + InitializeObjectAttributes(&attr, &us, 0, NULL, NULL); + + Status = NtOpenFile(&mountmgr, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb, + FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT); + + if (!NT_SUCCESS(Status)) + goto end; + + // MOUNTDEV_NAME is identical to MOUNTMGR_TARGET_NAME + Status = NtDeviceIoControlFile(mountmgr, NULL, NULL, NULL, &iosb, IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION, + mdn2, offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, NULL, 0); + if (!NT_SUCCESS(Status)) + goto end2; + + // MOUNTDEV_NAME is identical to MOUNTMGR_DRIVE_LETTER_TARGET + Status = NtDeviceIoControlFile(mountmgr, NULL, NULL, NULL, &iosb, IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, + mdn2, offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, &mdli, sizeof(mdli)); + if (!NT_SUCCESS(Status)) + goto end2; + +end2: + NtClose(mountmgr); + +end: +#ifndef __REACTOS__ + free(mdn2); +#else + RtlFreeHeap(RtlGetProcessHeap(), 0, mdn2); +#endif +} + +NTSTATUS NTAPI FormatEx(PUNICODE_STRING DriveRoot, FMIFS_MEDIA_FLAG MediaFlag, PUNICODE_STRING Label, + BOOLEAN QuickFormat, ULONG ClusterSize, PFMIFSCALLBACK Callback) +{ + NTSTATUS Status; + HANDLE h; + OBJECT_ATTRIBUTES attr; + IO_STATUS_BLOCK iosb; + GET_LENGTH_INFORMATION gli; + DISK_GEOMETRY_EX dgex; + UINT32 sector_size; + + InitializeObjectAttributes(&attr, DriveRoot, 0, NULL, NULL); + + Status = NtOpenFile(&h, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &attr, &iosb, + FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT); + + if (!NT_SUCCESS(Status)) + return Status; + + Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli)); + if (!NT_SUCCESS(Status)) { + NtClose(h); + return Status; + } + + Status = NtDeviceIoControlFile(h, NULL, NULL, NULL, &iosb, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, &dgex, sizeof(dgex)); + if (!NT_SUCCESS(Status)) { + NtClose(h); + return Status; + } + + sector_size = dgex.Geometry.BytesPerSector; + + if (sector_size == 0x200 || sector_size == 0) + sector_size = 0x1000; + + if (Callback) { + ULONG pc = 0; + Callback(PROGRESS, 0, (PVOID)&pc); + } + + NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0); + + if (is_mounted_multi_device(h, sector_size)) { + Status = STATUS_ACCESS_DENIED; + goto end; + } + + Status = write_btrfs(h, gli.Length.QuadPart, Label, sector_size); + + NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0); + +end: + NtFsControlFile(h, NULL, NULL, NULL, &iosb, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0); + + if (NT_SUCCESS(Status)) + add_drive_letter(h); + + NtClose(h); + + if (Callback) { + BOOL success = NT_SUCCESS(Status); + Callback(DONE, 0, (PVOID)&success); + } + + return Status; +} + +BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved) { + if (dwReason == DLL_PROCESS_ATTACH) + module = (HMODULE)hModule; + + return TRUE; +} Modified: trunk/reactos/dll/win32/ubtrfs/ubtrfs.rc URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/ubtrfs/ubtrfs.rc… ============================================================================== --- trunk/reactos/dll/win32/ubtrfs/ubtrfs.rc [iso-8859-1] (original) +++ trunk/reactos/dll/win32/ubtrfs/ubtrfs.rc [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -1,5 +1,101 @@ -#define REACTOS_VERSION_DLL -#define REACTOS_STR_FILE_DESCRIPTION "BTRFS File System Management" -#define REACTOS_STR_INTERNAL_NAME "ubtrfs" -#define REACTOS_STR_ORIGINAL_FILENAME "ubtrfs.dll" -#include <reactos/version.rc> +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.K.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENG) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x17L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "080904b0" + BEGIN + VALUE "FileDescription", "Btrfs utility DLL" + VALUE "FileVersion", "0.8" + VALUE "InternalName", "ubtrfs" + VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016" + VALUE "OriginalFilename", "ubtrfs.dll" + VALUE "ProductName", "WinBtrfs" + VALUE "ProductVersion", "0.8" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x809, 1200 + END +END + +#endif // English (U.K.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + Modified: trunk/reactos/dll/win32/ubtrfs/ubtrfs.spec URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/ubtrfs/ubtrfs.sp… ============================================================================== --- trunk/reactos/dll/win32/ubtrfs/ubtrfs.spec [iso-8859-1] (original) +++ trunk/reactos/dll/win32/ubtrfs/ubtrfs.spec [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -1,2 +1,2 @@ -@ stdcall ChkdskEx(ptr long long long long ptr) BtrfsChkdsk -@ stdcall FormatEx(ptr long ptr long long ptr) BtrfsFormat +@ stdcall ChkdskEx(ptr long long long long ptr) +@ stdcall FormatEx(ptr long ptr long long ptr) Modified: trunk/reactos/media/doc/README.FSD URL: http://svn.reactos.org/svn/reactos/trunk/reactos/media/doc/README.FSD?rev=7… ============================================================================== --- trunk/reactos/media/doc/README.FSD [iso-8859-1] (original) +++ trunk/reactos/media/doc/README.FSD [iso-8859-1] Mon Jan 9 20:52:44 2017 @@ -5,6 +5,7 @@ reactos/drivers/filesystems/btrfs # Synced to 0.8 reactos/dll/shellext/shellbtrfs # Synced to 0.7 +reactos/dll/win32/ubtrfs # Synced to 0.8 The following FSD are shared with: http://www.ext2fsd.com/

1 0

[pschweitzer] 73512: [SHELL32] When selecting any FAT filesystem on format dialog, uncheck & disable compression control. It's not supported by this FS.
by pschweitzer＠svn.reactos.org 08 Jan '17

08 Jan '17

Author: pschweitzer Date: Sun Jan 8 17:26:14 2017 New Revision: 73512 URL: http://svn.reactos.org/svn/reactos?rev=73512&view=rev Log: [SHELL32] When selecting any FAT filesystem on format dialog, uncheck & disable compression control. It's not supported by this FS. Modified: trunk/reactos/dll/win32/shell32/dialogs/drive.cpp Modified: trunk/reactos/dll/win32/shell32/dialogs/drive.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/dialogs/… ============================================================================== --- trunk/reactos/dll/win32/shell32/dialogs/drive.cpp [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shell32/dialogs/drive.cpp [iso-8859-1] Sun Jan 8 17:26:14 2017 @@ -229,6 +229,9 @@ SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize); SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0); } + + SendMessageW(GetDlgItem(hwndDlg, 28675), BM_SETCHECK, BST_UNCHECKED, 0); + EnableWindow(GetDlgItem(hwndDlg, 28675), FALSE); } else if (!wcsicmp(wszBuf, L"FAT32")) { @@ -248,6 +251,9 @@ SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize); SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0); } + + SendMessageW(GetDlgItem(hwndDlg, 28675), BM_SETCHECK, BST_UNCHECKED, 0); + EnableWindow(GetDlgItem(hwndDlg, 28675), FALSE); } else if (!wcsicmp(wszBuf, L"NTFS")) { @@ -279,6 +285,8 @@ } ClusterSize *= 2; } + + EnableWindow(GetDlgItem(hwndDlg, 28675), TRUE); } else if (!wcsicmp(wszBuf, L"EXT2")) { @@ -298,6 +306,8 @@ SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize); SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0); } + + EnableWindow(GetDlgItem(hwndDlg, 28675), TRUE); } else {

1 0

[pschweitzer] 73511: [PSDK] Define Button_SetElevationRequiredState() and BCM_SETSHIELD. Reviewed by Giannis. CORE-12617
by pschweitzer＠svn.reactos.org 07 Jan '17

07 Jan '17

Author: pschweitzer Date: Sat Jan 7 20:23:50 2017 New Revision: 73511 URL: http://svn.reactos.org/svn/reactos?rev=73511&view=rev Log: [PSDK] Define Button_SetElevationRequiredState() and BCM_SETSHIELD. Reviewed by Giannis. CORE-12617 Modified: trunk/reactos/sdk/include/psdk/commctrl.h Modified: trunk/reactos/sdk/include/psdk/commctrl.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/psdk/commctrl.… ============================================================================== --- trunk/reactos/sdk/include/psdk/commctrl.h [iso-8859-1] (original) +++ trunk/reactos/sdk/include/psdk/commctrl.h [iso-8859-1] Sat Jan 7 20:23:50 2017 @@ -4615,6 +4615,9 @@ #define BCM_GETTEXTMARGIN (BCM_FIRST+0x5) #define Button_GetTextMargin(hwnd,pmargin) (BOOL)SNDMSG((hwnd),BCM_GETTEXTMARGIN,0,(LPARAM)(pmargin)) +#define BCM_SETSHIELD (BCM_FIRST+0xC) +#define Button_SetElevationRequiredState(hwnd,frequired) (BOOL)SNDMSG((hwnd),BCM_SETSHIELD,0,(LPARAM)(frequired)) + typedef struct tagNMBCHOTITEM { NMHDR hdr; DWORD dwFlags;

1 0

[pschweitzer] 73510: [DDK] Define IDE_COMMAND_IDENTIFY CORE-12617
by pschweitzer＠svn.reactos.org 07 Jan '17

07 Jan '17

Author: pschweitzer Date: Sat Jan 7 20:20:21 2017 New Revision: 73510 URL: http://svn.reactos.org/svn/reactos?rev=73510&view=rev Log: [DDK] Define IDE_COMMAND_IDENTIFY CORE-12617 Modified: trunk/reactos/sdk/include/ddk/ata.h Modified: trunk/reactos/sdk/include/ddk/ata.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/ddk/ata.h?rev=… ============================================================================== --- trunk/reactos/sdk/include/ddk/ata.h [iso-8859-1] (original) +++ trunk/reactos/sdk/include/ddk/ata.h [iso-8859-1] Sat Jan 7 20:20:21 2017 @@ -252,4 +252,6 @@ } IDENTIFY_DEVICE_DATA, *PIDENTIFY_DEVICE_DATA; #include <poppack.h> +#define IDE_COMMAND_IDENTIFY 0xEC + #endif

1 0

[gadamopoulos] 73509: [KERNEL32_APITEST] - Use the full path to the manifest files when testing FindActCtxSectionStringW. This is needed because in most cases they are not in the current directory.
by gadamopoulos＠svn.reactos.org 06 Jan '17

06 Jan '17

Author: gadamopoulos Date: Fri Jan 6 22:06:53 2017 New Revision: 73509 URL: http://svn.reactos.org/svn/reactos?rev=73509&view=rev Log: [KERNEL32_APITEST] - Use the full path to the manifest files when testing FindActCtxSectionStringW. This is needed because in most cases they are not in the current directory. Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/FindAct… ============================================================================== --- trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] Fri Jan 6 22:06:53 2017 @@ -79,8 +79,16 @@ HANDLE _CreateActCtxFromFile(LPCWSTR FileName, int line) { - ACTCTXW ActCtx = {sizeof(ACTCTX), 0, FileName}; + ACTCTXW ActCtx = {sizeof(ACTCTX)}; HANDLE h; + WCHAR buffer[MAX_PATH] , *separator; + + ok (GetModuleFileNameW(NULL, buffer, MAX_PATH), "GetModuleFileName failed\n"); + separator = wcsrchr(buffer, L'\\'); + if (separator) + wcscpy(separator + 1, FileName); + + ActCtx.lpSource = buffer; SetLastError(0xdeaddead); h = CreateActCtxW(&ActCtx);

1 0

[gadamopoulos] 73508: [KERNEL32_APITEST] -Keep improving the skip checks.
by gadamopoulos＠svn.reactos.org 06 Jan '17

06 Jan '17

Author: gadamopoulos Date: Fri Jan 6 21:25:53 2017 New Revision: 73508 URL: http://svn.reactos.org/svn/reactos?rev=73508&view=rev Log: [KERNEL32_APITEST] -Keep improving the skip checks. Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/FindAct… ============================================================================== --- trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] Fri Jan 6 21:25:53 2017 @@ -272,7 +272,7 @@ /* Class redirection tests */ h = _CreateActCtxFromFile(L"classtest.manifest", __LINE__); - if (h) + if (h != INVALID_HANDLE_VALUE) { _ActivateCtx(h, &cookie, __LINE__); TestClassRedirection(h, L"Button", L"2.2.2.2!Button", L"testlib.dll", 5); @@ -285,7 +285,7 @@ /* Dependency tests */ h = _CreateActCtxFromFile(L"deptest.manifest", __LINE__); - if (h) + if (h != INVALID_HANDLE_VALUE) { _ActivateCtx(h, &cookie, __LINE__); TestLibDependency(h); @@ -298,7 +298,7 @@ /* Activate a context that depends on comctl32 v6 and run class tests again */ h = _CreateActCtxFromFile(L"comctl32dep.manifest", __LINE__); - if (h) + if (h != INVALID_HANDLE_VALUE) { _ActivateCtx(h, &cookie, __LINE__); TestClassRedirection(h, L"Button", L"6.0.3790.1830!Button", L"comctl32.dll", 29);

1 0

[gadamopoulos] 73507: [KERNEL32_APITEST] - Skip more stuff hoping to fix a crash that I can't reproduce locally.
by gadamopoulos＠svn.reactos.org 06 Jan '17

06 Jan '17

Author: gadamopoulos Date: Fri Jan 6 21:13:46 2017 New Revision: 73507 URL: http://svn.reactos.org/svn/reactos?rev=73507&view=rev Log: [KERNEL32_APITEST] - Skip more stuff hoping to fix a crash that I can't reproduce locally. Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/FindAct… ============================================================================== --- trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] Fri Jan 6 21:13:46 2017 @@ -272,22 +272,42 @@ /* Class redirection tests */ h = _CreateActCtxFromFile(L"classtest.manifest", __LINE__); - _ActivateCtx(h, &cookie, __LINE__); - TestClassRedirection(h, L"Button", L"2.2.2.2!Button", L"testlib.dll", 5); - _DeactivateCtx(cookie, __LINE__); + if (h) + { + _ActivateCtx(h, &cookie, __LINE__); + TestClassRedirection(h, L"Button", L"2.2.2.2!Button", L"testlib.dll", 5); + _DeactivateCtx(cookie, __LINE__); + } + else + { + skip("Failed to create context for classtest.manifest\n"); + } /* Dependency tests */ h = _CreateActCtxFromFile(L"deptest.manifest", __LINE__); - _ActivateCtx(h, &cookie, __LINE__); - TestLibDependency(h); - _DeactivateCtx(cookie, __LINE__); + if (h) + { + _ActivateCtx(h, &cookie, __LINE__); + TestLibDependency(h); + _DeactivateCtx(cookie, __LINE__); + } + else + { + skip("Failed to create context for deptest.manifest\n"); + } /* Activate a context that depends on comctl32 v6 and run class tests again */ h = _CreateActCtxFromFile(L"comctl32dep.manifest", __LINE__); - _ActivateCtx(h, &cookie, __LINE__); - TestClassRedirection(h, L"Button", L"6.0.3790.1830!Button", L"comctl32.dll", 29); - ok( GetModuleHandleW(L"comctl32.dll") == NULL, "Expected comctl32 not to be loaded\n"); - ok( GetModuleHandleW(L"user32.dll") == NULL, "Expected user32 not to be loaded\n"); - _DeactivateCtx(cookie, __LINE__); - + if (h) + { + _ActivateCtx(h, &cookie, __LINE__); + TestClassRedirection(h, L"Button", L"6.0.3790.1830!Button", L"comctl32.dll", 29); + ok( GetModuleHandleW(L"comctl32.dll") == NULL, "Expected comctl32 not to be loaded\n"); + ok( GetModuleHandleW(L"user32.dll") == NULL, "Expected user32 not to be loaded\n"); + _DeactivateCtx(cookie, __LINE__); + } + else + { + skip("Failed to create context for comctl32dep.manifest\n"); + } }

1 0

[gadamopoulos] 73506: [KERNEL32_APITEST] -Add some more checks to avoid a crash (the ones I originally added were not enough).
by gadamopoulos＠svn.reactos.org 06 Jan '17

06 Jan '17

Author: gadamopoulos Date: Fri Jan 6 20:43:58 2017 New Revision: 73506 URL: http://svn.reactos.org/svn/reactos?rev=73506&view=rev Log: [KERNEL32_APITEST] -Add some more checks to avoid a crash (the ones I originally added were not enough). Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c Modified: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/FindAct… ============================================================================== --- trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] Fri Jan 6 20:43:58 2017 @@ -130,27 +130,34 @@ ok(res == TRUE, "FindActCtxSectionString failed\n"); ok(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); - ok(KeyedData.ulDataFormatVersion == 1, "Wrong format version: %lu", KeyedData.ulDataFormatVersion); + ok(KeyedData.ulDataFormatVersion == 1, "Wrong format version: %lu\n", KeyedData.ulDataFormatVersion); ok(KeyedData.hActCtx == h, "Wrong handle\n"); ok(KeyedData.lpSectionBase != NULL, "Expected non null lpSectionBase\n"); ok(KeyedData.lpData != NULL, "Expected non null lpData\n"); header = (struct strsection_header*)KeyedData.lpSectionBase; classData = (struct wndclass_redirect_data*)KeyedData.lpData; - ok(header->magic == STRSECTION_MAGIC, "%lu\n", header->magic ); - ok(header->size == sizeof(*header), "Got %lu instead of %d\n", header->size, sizeof(*header)); - ok(header->count == ExpectedClassCount, "Expected %lu classes, got %lu\n", ExpectedClassCount, header->count ); - - VersionedClass = (WCHAR*)((BYTE*)classData + classData->name_offset); - ClassLib = (WCHAR*)((BYTE*)header + classData->module_offset); - data_lenght = classData->size + classData->name_len + classData->module_len + 2*sizeof(WCHAR); - ok(KeyedData.ulLength == data_lenght, "Got lenght %lu instead of %d\n", KeyedData.ulLength, data_lenght); - ok(classData->size == sizeof(*classData), "Got %lu instead of %d\n", classData->size, sizeof(*classData)); - ok(classData->res == 0, "Got res %lu\n", classData->res); - ok(classData->name_len == wcslen(ExpectedClassName) * 2, "Got name len %lu, expected %d\n", classData->name_len, wcslen(ExpectedClassName) *2); - ok(classData->module_len == wcslen(ExpectedModule) * 2, "Got name len %lu, expected %d\n", classData->module_len, wcslen(ExpectedModule) *2); - ok(wcscmp(VersionedClass, ExpectedClassName) == 0, "Got %S, expected %S\n", VersionedClass, ExpectedClassName); - ok(wcscmp(ClassLib, ExpectedModule) == 0, "Got %S, expected %S\n", ClassLib, ExpectedModule); + if(res == FALSE || KeyedData.ulDataFormatVersion != 1 || header == NULL || classData == NULL) + { + skip("Can't read data for class. Skipping\n"); + } + else + { + ok(header->magic == STRSECTION_MAGIC, "%lu\n", header->magic ); + ok(header->size == sizeof(*header), "Got %lu instead of %d\n", header->size, sizeof(*header)); + ok(header->count == ExpectedClassCount, "Expected %lu classes, got %lu\n", ExpectedClassCount, header->count ); + + VersionedClass = (WCHAR*)((BYTE*)classData + classData->name_offset); + ClassLib = (WCHAR*)((BYTE*)header + classData->module_offset); + data_lenght = classData->size + classData->name_len + classData->module_len + 2*sizeof(WCHAR); + ok(KeyedData.ulLength == data_lenght, "Got lenght %lu instead of %d\n", KeyedData.ulLength, data_lenght); + ok(classData->size == sizeof(*classData), "Got %lu instead of %d\n", classData->size, sizeof(*classData)); + ok(classData->res == 0, "Got res %lu\n", classData->res); + ok(classData->name_len == wcslen(ExpectedClassName) * 2, "Got name len %lu, expected %d\n", classData->name_len, wcslen(ExpectedClassName) *2); + ok(classData->module_len == wcslen(ExpectedModule) * 2, "Got name len %lu, expected %d\n", classData->module_len, wcslen(ExpectedModule) *2); + ok(wcscmp(VersionedClass, ExpectedClassName) == 0, "Got %S, expected %S\n", VersionedClass, ExpectedClassName); + ok(wcscmp(ClassLib, ExpectedModule) == 0, "Got %S, expected %S\n", ClassLib, ExpectedModule); + } } VOID TestLibDependency(HANDLE h) @@ -178,7 +185,7 @@ SectionHeader = (struct strsection_header*)KeyedData.lpSectionBase; redirData = (struct dllredirect_data *)KeyedData.lpData; - if(res == FALSE || KeyedData.ulDataFormatVersion != 1) + if(res == FALSE || KeyedData.ulDataFormatVersion != 1 || SectionHeader == NULL || redirData == NULL) { skip("Can't read data for dep1.dll. Skipping\n"); } @@ -206,7 +213,7 @@ SectionHeader = (struct strsection_header*)KeyedData.lpSectionBase; assemplyData = (struct assemply_data*)KeyedData.lpData;; - if(res == FALSE || KeyedData.ulDataFormatVersion != 1) + if(res == FALSE || KeyedData.ulDataFormatVersion != 1 || SectionHeader == NULL || assemplyData == NULL) { skip("Can't read data for dep1. Skipping\n"); }

1 0

[gadamopoulos] 73505: [KERNEL32_APITEST] -Add tests for FindActCtxSectionStringW.
by gadamopoulos＠svn.reactos.org 06 Jan '17

06 Jan '17

Author: gadamopoulos Date: Fri Jan 6 18:48:15 2017 New Revision: 73505 URL: http://svn.reactos.org/svn/reactos?rev=73505&view=rev Log: [KERNEL32_APITEST] -Add tests for FindActCtxSectionStringW. Added: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c (with props) trunk/rostests/apitests/kernel32/classtest.manifest (with props) trunk/rostests/apitests/kernel32/comctl32dep.manifest (with props) trunk/rostests/apitests/kernel32/dep1.manifest (with props) trunk/rostests/apitests/kernel32/deptest.manifest (with props) Modified: trunk/rostests/apitests/kernel32/CMakeLists.txt trunk/rostests/apitests/kernel32/testlist.c Modified: trunk/rostests/apitests/kernel32/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/CMakeLi… ============================================================================== --- trunk/rostests/apitests/kernel32/CMakeLists.txt [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/CMakeLists.txt [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -1,6 +1,7 @@ list(APPEND SOURCE dosdev.c + FindActCtxSectionStringW.c FindFiles.c GetComputerNameEx.c GetCurrentDirectory.c @@ -22,5 +23,16 @@ add_executable(kernel32_apitest ${SOURCE}) target_link_libraries(kernel32_apitest wine ${PSEH_LIB}) set_module_type(kernel32_apitest win32cui) -add_importlibs(kernel32_apitest advapi32 gdi32 user32 shlwapi msvcrt kernel32 ntdll) +add_delay_importlibs(kernel32_apitest advapi32 shlwapi) +add_importlibs(kernel32_apitest msvcrt kernel32 ntdll) add_cd_file(TARGET kernel32_apitest DESTINATION reactos/bin FOR all) + +list(APPEND MANIFEST_FILES + classtest.manifest + comctl32dep.manifest + dep1.manifest + deptest.manifest) + +foreach(item ${MANIFEST_FILES}) + add_cd_file(FILE "${CMAKE_CURRENT_SOURCE_DIR}/${item}" DESTINATION reactos/bin FOR all) +endforeach(item) Added: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/FindAct… ============================================================================== --- trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c (added) +++ trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -0,0 +1,286 @@ +/* + * Unit test suite for virtual substituted drive functions. + * + * Copyright 2017 Giannis Adamopoulos + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> +#include <stdio.h> + +#include "wine/test.h" +#include "windef.h" +#include "winbase.h" +#include "winerror.h" + +#define STRSECTION_MAGIC 0x64487353 /* dHsS */ + +struct strsection_header +{ + DWORD magic; + ULONG size; + DWORD unk1[3]; + ULONG count; + ULONG index_offset; + DWORD unk2[2]; + ULONG global_offset; + ULONG global_len; +}; + +struct wndclass_redirect_data +{ + ULONG size; + DWORD res; + ULONG name_len; + ULONG name_offset; /* versioned name offset */ + ULONG module_len; + ULONG module_offset; /* container name offset to the section base */ +}; + +struct dllredirect_data +{ + ULONG size; + ULONG unk; + DWORD res[3]; +}; + +#include <pshpack1.h> + +struct assemply_data +{ + ULONG size; + DWORD ulFlags; + DWORD ulEncodedAssemblyIdentityLength; + DWORD ulEncodedAssemblyIdentityOffset; /* offset to the section base */ + DWORD ulManifestPathType; + DWORD ulManifestPathLength; + DWORD ulManifestPathOffset; /* offset to the section base */ + LARGE_INTEGER liManifestLastWriteTime; + DWORD unk3[11]; + DWORD ulAssemblyDirectoryNameLength; + DWORD ulAssemblyDirectoryNameOffset; /* offset to the section base */ + DWORD unk4[3]; /* In win10 there are two more fields */ +}; + +#include <poppack.h> + +HANDLE _CreateActCtxFromFile(LPCWSTR FileName, int line) +{ + ACTCTXW ActCtx = {sizeof(ACTCTX), 0, FileName}; + HANDLE h; + + SetLastError(0xdeaddead); + h = CreateActCtxW(&ActCtx); + ok_(__FILE__, line)(h != INVALID_HANDLE_VALUE, "CreateActCtx failed\n"); + // In win10 last error is unchanged and in win2k3 it is ERROR_BAD_EXE_FORMAT + ok_(__FILE__, line)(GetLastError() == ERROR_BAD_EXE_FORMAT, "Wrong last error. Expected %d, got %lu\n", ERROR_BAD_EXE_FORMAT, GetLastError()); + + return h; +} + +VOID _ActivateCtx(HANDLE h, ULONG_PTR *cookie, int line) +{ + BOOL res; + + SetLastError(0xdeaddead); + res = ActivateActCtx(h, cookie); + ok_(__FILE__, line)(res == TRUE, "ActivateActCtx failed\n"); + ok_(__FILE__, line)(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); +} + +VOID _DeactivateCtx(ULONG_PTR cookie, int line) +{ + BOOL res; + + SetLastError(0xdeaddead); + res = DeactivateActCtx(0, cookie); + ok_(__FILE__, line)(res == TRUE, "DeactivateActCtx failed\n"); + ok_(__FILE__, line)(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); +} + +void TestClassRedirection(HANDLE h, LPCWSTR ClassToTest, LPCWSTR ExpectedClassName, LPCWSTR ExpectedModule, ULONG ExpectedClassCount) +{ + ACTCTX_SECTION_KEYED_DATA KeyedData = { 0 }; + BOOL res; + struct strsection_header *header; + struct wndclass_redirect_data *classData; + LPCWSTR VersionedClass, ClassLib; + int data_lenght; + + SetLastError(0xdeaddead); + KeyedData.cbSize = sizeof(KeyedData); + res = FindActCtxSectionStringW(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, + NULL, + ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, + ClassToTest, + &KeyedData); + ok(res == TRUE, "FindActCtxSectionString failed\n"); + ok(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); + + ok(KeyedData.ulDataFormatVersion == 1, "Wrong format version: %lu", KeyedData.ulDataFormatVersion); + ok(KeyedData.hActCtx == h, "Wrong handle\n"); + ok(KeyedData.lpSectionBase != NULL, "Expected non null lpSectionBase\n"); + ok(KeyedData.lpData != NULL, "Expected non null lpData\n"); + header = (struct strsection_header*)KeyedData.lpSectionBase; + classData = (struct wndclass_redirect_data*)KeyedData.lpData; + + ok(header->magic == STRSECTION_MAGIC, "%lu\n", header->magic ); + ok(header->size == sizeof(*header), "Got %lu instead of %d\n", header->size, sizeof(*header)); + ok(header->count == ExpectedClassCount, "Expected %lu classes, got %lu\n", ExpectedClassCount, header->count ); + + VersionedClass = (WCHAR*)((BYTE*)classData + classData->name_offset); + ClassLib = (WCHAR*)((BYTE*)header + classData->module_offset); + data_lenght = classData->size + classData->name_len + classData->module_len + 2*sizeof(WCHAR); + ok(KeyedData.ulLength == data_lenght, "Got lenght %lu instead of %d\n", KeyedData.ulLength, data_lenght); + ok(classData->size == sizeof(*classData), "Got %lu instead of %d\n", classData->size, sizeof(*classData)); + ok(classData->res == 0, "Got res %lu\n", classData->res); + ok(classData->name_len == wcslen(ExpectedClassName) * 2, "Got name len %lu, expected %d\n", classData->name_len, wcslen(ExpectedClassName) *2); + ok(classData->module_len == wcslen(ExpectedModule) * 2, "Got name len %lu, expected %d\n", classData->module_len, wcslen(ExpectedModule) *2); + ok(wcscmp(VersionedClass, ExpectedClassName) == 0, "Got %S, expected %S\n", VersionedClass, ExpectedClassName); + ok(wcscmp(ClassLib, ExpectedModule) == 0, "Got %S, expected %S\n", ClassLib, ExpectedModule); +} + +VOID TestLibDependency(HANDLE h) +{ + ACTCTX_SECTION_KEYED_DATA KeyedData = { 0 }; + BOOL res; + struct strsection_header *SectionHeader; + struct dllredirect_data *redirData; + struct assemply_data *assemplyData; + + SetLastError(0xdeaddead); + KeyedData.cbSize = sizeof(KeyedData); + res = FindActCtxSectionStringW(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, + NULL, + ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, + L"dep1.dll", + &KeyedData); + ok(res == TRUE, "FindActCtxSectionString failed\n"); + ok(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); + + ok(KeyedData.ulDataFormatVersion == 1, "Wrong format version: %lu", KeyedData.ulDataFormatVersion); + ok(KeyedData.hActCtx == h, "Wrong handle\n"); + ok(KeyedData.lpSectionBase != NULL, "Expected non null lpSectionBase\n"); + ok(KeyedData.lpData != NULL, "Expected non null lpData\n"); + SectionHeader = (struct strsection_header*)KeyedData.lpSectionBase; + redirData = (struct dllredirect_data *)KeyedData.lpData; + + if(res == FALSE || KeyedData.ulDataFormatVersion != 1) + { + skip("Can't read data for dep1.dll. Skipping\n"); + } + else + { + ok(SectionHeader->magic == STRSECTION_MAGIC, "%lu\n", SectionHeader->magic ); + ok(SectionHeader->size == sizeof(*SectionHeader), "Got %lu instead of %d\n", SectionHeader->size, sizeof(*SectionHeader)); + ok(SectionHeader->count == 2, "%lu\n", SectionHeader->count ); /* 2 dlls? */ + ok(redirData->size == sizeof(*redirData), "Got %lu instead of %d\n", redirData->size, sizeof(*redirData)); + } + + SetLastError(0xdeaddead); + KeyedData.cbSize = sizeof(KeyedData); + res = FindActCtxSectionStringW(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, + NULL, + ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, + L"dep1", + &KeyedData); + ok(res == TRUE, "FindActCtxSectionString failed\n"); + ok(GetLastError() == 0xdeaddead, "Wrong last error. Expected %lu, got %lu\n", (DWORD)(0xdeaddead), GetLastError()); + ok(KeyedData.ulDataFormatVersion == 1, "Wrong format version: %lu", KeyedData.ulDataFormatVersion); + ok(KeyedData.hActCtx == h, "Wrong handle\n"); + ok(KeyedData.lpSectionBase != NULL, "Expected non null lpSectionBase\n"); + ok(KeyedData.lpData != NULL, "Expected non null lpData\n"); + SectionHeader = (struct strsection_header*)KeyedData.lpSectionBase; + assemplyData = (struct assemply_data*)KeyedData.lpData;; + + if(res == FALSE || KeyedData.ulDataFormatVersion != 1) + { + skip("Can't read data for dep1. Skipping\n"); + } + else + { + LPCWSTR AssemblyIdentity, ManifestPath, AssemblyDirectory; + int data_lenght; + DWORD buffer[256]; + PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION details = (PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION)buffer; + + ok(SectionHeader->magic == STRSECTION_MAGIC, "%lu\n", SectionHeader->magic ); + ok(SectionHeader->size == sizeof(*SectionHeader), "Got %lu instead of %d\n", SectionHeader->size, sizeof(*SectionHeader)); + ok(SectionHeader->count == 2, "%lu\n", SectionHeader->count ); /* 2 dlls? */ + + data_lenght = assemplyData->size + + assemplyData->ulEncodedAssemblyIdentityLength + + assemplyData->ulManifestPathLength + + assemplyData->ulAssemblyDirectoryNameLength + 2 * sizeof(WCHAR); + ok(assemplyData->size == sizeof(*assemplyData), "Got %lu instead of %d\n", assemplyData->size, sizeof(*assemplyData)); + ok(KeyedData.ulLength == data_lenght, "Got lenght %lu instead of %d\n", KeyedData.ulLength, data_lenght); + + AssemblyIdentity = (WCHAR*)((BYTE*)SectionHeader + assemplyData->ulEncodedAssemblyIdentityOffset); + ManifestPath = (WCHAR*)((BYTE*)SectionHeader + assemplyData->ulManifestPathOffset); + AssemblyDirectory = (WCHAR*)((BYTE*)SectionHeader + assemplyData->ulAssemblyDirectoryNameOffset); + + /* Use AssemblyDetailedInformationInActivationContext so as to infer the contents of assemplyData */ + res = QueryActCtxW(0, h, &KeyedData.ulAssemblyRosterIndex, + AssemblyDetailedInformationInActivationContext, + &buffer, sizeof(buffer), NULL); + ok(res == TRUE, "QueryActCtxW failed\n"); + ok(assemplyData->ulFlags == details->ulFlags, "\n"); + ok(assemplyData->ulEncodedAssemblyIdentityLength == details->ulEncodedAssemblyIdentityLength, "\n"); + ok(assemplyData->ulManifestPathType == details->ulManifestPathType, "\n"); + ok(assemplyData->ulManifestPathLength == details->ulManifestPathLength, "\n"); + ok(assemplyData->ulAssemblyDirectoryNameLength == details->ulAssemblyDirectoryNameLength, "\n"); + ok(assemplyData->liManifestLastWriteTime.QuadPart == details->liManifestLastWriteTime.QuadPart, "\n"); + + ok(wcscmp(ManifestPath, details->lpAssemblyManifestPath) == 0, "Expected path %S, got %S\n", details->lpAssemblyManifestPath, ManifestPath); + ok(wcscmp(AssemblyDirectory, details->lpAssemblyDirectoryName) == 0, "Expected path %S, got %S\n", details->lpAssemblyManifestPath, ManifestPath); + + /* It looks like that AssemblyIdentity isn't null terminated */ + ok(memcmp(AssemblyIdentity, details->lpAssemblyEncodedAssemblyIdentity, assemplyData->ulEncodedAssemblyIdentityLength) == 0, "Got wrong AssemblyIdentity\n"); + } +} + +START_TEST(FindActCtxSectionStringW) +{ + HANDLE h; + ULONG_PTR cookie; + + /*First run the redirection tests without using our own actctx */ + TestClassRedirection(NULL, L"Button", L"Button", L"comctl32.dll", 27); + /* Something activates an activation context that mentions comctl32 but comctl32 is not loaded */ + ok( GetModuleHandleW(L"comctl32.dll") == NULL, "Expected comctl32 not to be loaded\n"); + ok( GetModuleHandleW(L"user32.dll") == NULL, "Expected user32 not to be loaded\n"); + + /* Class redirection tests */ + h = _CreateActCtxFromFile(L"classtest.manifest", __LINE__); + _ActivateCtx(h, &cookie, __LINE__); + TestClassRedirection(h, L"Button", L"2.2.2.2!Button", L"testlib.dll", 5); + _DeactivateCtx(cookie, __LINE__); + + /* Dependency tests */ + h = _CreateActCtxFromFile(L"deptest.manifest", __LINE__); + _ActivateCtx(h, &cookie, __LINE__); + TestLibDependency(h); + _DeactivateCtx(cookie, __LINE__); + + /* Activate a context that depends on comctl32 v6 and run class tests again */ + h = _CreateActCtxFromFile(L"comctl32dep.manifest", __LINE__); + _ActivateCtx(h, &cookie, __LINE__); + TestClassRedirection(h, L"Button", L"6.0.3790.1830!Button", L"comctl32.dll", 29); + ok( GetModuleHandleW(L"comctl32.dll") == NULL, "Expected comctl32 not to be loaded\n"); + ok( GetModuleHandleW(L"user32.dll") == NULL, "Expected user32 not to be loaded\n"); + _DeactivateCtx(cookie, __LINE__); + +} Propchange: trunk/rostests/apitests/kernel32/FindActCtxSectionStringW.c ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/rostests/apitests/kernel32/classtest.manifest URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/classte… ============================================================================== --- trunk/rostests/apitests/kernel32/classtest.manifest (added) +++ trunk/rostests/apitests/kernel32/classtest.manifest [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -0,0 +1,11 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" name="ReactOS-TestLib" version="2.2.2.2" processorArchitecture="x86" publicKeyToken="6595b64144ccf1df"/> + <file name="testlib.dll"> + <windowClass>Button</windowClass> + <windowClass>ButtonListBox</windowClass> + <windowClass>ComboBoxEx32</windowClass> + <windowClass>ComboLBox</windowClass> + <windowClass>Combobox</windowClass> + </file> +</assembly> Propchange: trunk/rostests/apitests/kernel32/classtest.manifest ------------------------------------------------------------------------------ svn:eol-style = CRLF Added: trunk/rostests/apitests/kernel32/comctl32dep.manifest URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/comctl3… ============================================================================== --- trunk/rostests/apitests/kernel32/comctl32dep.manifest (added) +++ trunk/rostests/apitests/kernel32/comctl32dep.manifest [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + publicKeyToken="6595b64144ccf1df" + processorArchitecture="*" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> Propchange: trunk/rostests/apitests/kernel32/comctl32dep.manifest ------------------------------------------------------------------------------ svn:eol-style = CRLF Added: trunk/rostests/apitests/kernel32/dep1.manifest URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/dep1.ma… ============================================================================== --- trunk/rostests/apitests/kernel32/dep1.manifest (added) +++ trunk/rostests/apitests/kernel32/dep1.manifest [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -0,0 +1,5 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" name="dep1" version="0.4.4.0" processorArchitecture="x86" /> + <file name="dep1.dll"/> +</assembly> Propchange: trunk/rostests/apitests/kernel32/dep1.manifest ------------------------------------------------------------------------------ svn:eol-style = CRLF Added: trunk/rostests/apitests/kernel32/deptest.manifest URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/deptest… ============================================================================== --- trunk/rostests/apitests/kernel32/deptest.manifest (added) +++ trunk/rostests/apitests/kernel32/deptest.manifest [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" name="ReactOS-deptest" version="1.0.0.0"/> + <dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="dep1" + version="0.4.4.0" + processorArchitecture="x86" + /> + </dependentAssembly> + </dependency> + <file name="deptest.dll"/> +</assembly> Propchange: trunk/rostests/apitests/kernel32/deptest.manifest ------------------------------------------------------------------------------ svn:eol-style = CRLF Modified: trunk/rostests/apitests/kernel32/testlist.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/apitests/kernel32/testlis… ============================================================================== --- trunk/rostests/apitests/kernel32/testlist.c [iso-8859-1] (original) +++ trunk/rostests/apitests/kernel32/testlist.c [iso-8859-1] Fri Jan 6 18:48:15 2017 @@ -4,6 +4,7 @@ #include <apitest.h> extern void func_dosdev(void); +extern void func_FindActCtxSectionStringW(void); extern void func_FindFiles(void); extern void func_GetComputerNameEx(void); extern void func_GetCurrentDirectory(void); @@ -24,6 +25,7 @@ const struct test winetest_testlist[] = { { "dosdev", func_dosdev }, + { "FindActCtxSectionStringW", func_FindActCtxSectionStringW }, { "FindFiles", func_FindFiles }, { "GetComputerNameEx", func_GetComputerNameEx }, { "GetCurrentDirectory", func_GetCurrentDirectory },

1 0

[sserapion] 73504: [NTLM] Commit ancient code that was dormant in my working copy: Mostly some style fixes, allocation checks, debug messages. Implement QueryCredentialsAttributes SECPKG_ATTR_NAMES...
by sserapion＠svn.reactos.org 05 Jan '17

05 Jan '17

Author: sserapion Date: Thu Jan 5 19:53:57 2017 New Revision: 73504 URL: http://svn.reactos.org/svn/reactos?rev=73504&view=rev Log: [NTLM] Commit ancient code that was dormant in my working copy: Mostly some style fixes, allocation checks, debug messages. Implement QueryCredentialsAttributes SECPKG_ATTR_NAMES case Enable/disable the use of crypto api RNG with USE_CRYPTOAPI, probably could use crypto api for RC4 and other such things as well. Implement message support with EncryptMessage, DecryptMessage Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/CMakeLists.txt branches/sspi-bringup/reactos/dll/win32/ntlmssp/avl.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/calculations.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/ciphers.h branches/sspi-bringup/reactos/dll/win32/ntlmssp/context.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/credentials.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/crypt.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/debug.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/dllmain.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/messages.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.h branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.h branches/sspi-bringup/reactos/dll/win32/ntlmssp/sign.c branches/sspi-bringup/reactos/dll/win32/ntlmssp/util.c Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/CMakeLists.txt [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/CMakeLists.txt [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -1,7 +1,7 @@ -spec2def(ntlmssp.dll ntlmssp.spec) +spec2def(ntlmssp.dll ntlmssp.spec ADD_IMPORTLIB) list(APPEND SOURCE - avl.c + avl.c calculations.c ciphers.c context.c @@ -9,17 +9,17 @@ crypt.c debug.c dllmain.c - messages.c + messages.c ntlmssp.c protocol.c stubs.c sign.c util.c - ${CMAKE_CURRENT_BINARY_DIR}/ntlmssp_stubs.c - ${CMAKE_CURRENT_BINARY_DIR}/ntlmssp.def) + ${CMAKE_CURRENT_BINARY_DIR}/ntlmssp_stubs.c + ${CMAKE_CURRENT_BINARY_DIR}/ntlmssp.def) add_library(ntlmssp SHARED ${SOURCE}) - +allow_warnings(ntlmssp) set_module_type(ntlmssp win32dll UNICODE) target_link_libraries(ntlmssp wine) @@ -27,4 +27,4 @@ add_importlibs(ntlmssp advapi32 crypt32 netapi32 msvcrt kernel32 ntdll) add_cd_file(TARGET ntlmssp DESTINATION reactos/system32 FOR all) -add_importlib_target(ntlmssp.spec) +#add_importlib_target(ntlmssp.spec) Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/avl.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/avl.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/avl.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -19,6 +19,9 @@ #include "ntlmssp.h" #include "protocol.h" + +#include "wine/debug.h" +WINE_DEFAULT_DEBUG_CHANNEL(ntlm); PMSV1_0_AV_PAIR NtlmAvlInit(IN void * pAvList) @@ -47,7 +50,8 @@ return NULL; pAvPair = (PMSV1_0_AV_PAIR)((PUCHAR)pAvPair + pAvPair->AvLen + sizeof(MSV1_0_AV_PAIR)); - }while(1); + }while(pAvPair); + return NULL; } ULONG Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/calculations.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/calculations.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/calculations.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -27,7 +27,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(ntlm); VOID -NTOWFv1(const PWCHAR password, +NTOWFv1(LPCWSTR password, PUCHAR result) { ULONG i, len = wcslen(password); @@ -40,15 +40,18 @@ MD4((PUCHAR)pass, 14, result); } -VOID -NTOWFv2(const PWCHAR password, const PWCHAR user, const PWCHAR domain, PUCHAR result) +BOOLEAN +NTOWFv2(LPCWSTR password, + LPCWSTR user, + LPCWSTR domain, + PUCHAR result) { UCHAR response_key_nt_v1 [16]; ULONG len_user = user ? wcslen(user) : 0; ULONG len_domain = domain ? wcslen(domain) : 0; - WCHAR user_upper[len_user + 1]; ULONG len_user_u = len_user * sizeof(WCHAR); ULONG len_domain_u = len_domain * sizeof(WCHAR); + WCHAR user_upper[len_user + 1]; WCHAR buff[len_user + len_domain]; ULONG i; @@ -62,10 +65,12 @@ NTOWFv1(password, response_key_nt_v1); HMAC_MD5(response_key_nt_v1, 16, (PUCHAR)buff, len_user_u + len_domain_u, result); -} - -VOID -LMOWFv1(PCCHAR password, PUCHAR result) + + return TRUE; +} + +VOID +LMOWFv1(const PCCHAR password, PUCHAR result) { #if 0 SystemFunction006(password, result); @@ -95,14 +100,18 @@ #endif } -VOID -LMOWFv2(PWCHAR password, PWCHAR user, PWCHAR domain, PUCHAR result) -{ - NTOWFv2(password, user, domain, result); -} - -VOID -NONCE(PUCHAR buffer, ULONG num) +BOOLEAN +LMOWFv2(LPCWSTR password, + LPCWSTR user, + LPCWSTR domain, + PUCHAR result) +{ + return NTOWFv2(password, user, domain, result); +} + +VOID +NONCE(PUCHAR buffer, + ULONG num) { NtlmGenerateRandomBits(buffer, num); } @@ -118,21 +127,23 @@ memcpy(key_exchange_key, session_base_key, 16); } -VOID +BOOLEAN SIGNKEY(const PUCHAR RandomSessionKey, BOOLEAN IsClient, PUCHAR Result) { PCHAR magic = IsClient ? "session key to client-to-server signing key magic constant" : "session key to server-to-client signing key magic constant"; - ULONG len = strlen(magic); - UCHAR md5_input [16 + len]; + UCHAR md5_input[16 + len]; + memcpy(md5_input, RandomSessionKey, 16); memcpy(md5_input + 16, magic, len); MD5(md5_input, len + 16, Result); -} - -VOID + + return TRUE; +} + +BOOLEAN SEALKEY(ULONG flags, const PUCHAR RandomSessionKey, BOOLEAN client, PUCHAR result) { if (flags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) @@ -142,8 +153,15 @@ : "session key to server-to-client sealing key magic constant"; ULONG len = strlen(magic) + 1; - UCHAR md5_input [16 + len]; + UCHAR* md5_input; ULONG key_len; + + md5_input = (UCHAR*)NtlmAllocate(16+len); + if(!md5_input) + { + ERR("Out of memory\n"); + return FALSE; + } if (flags & NTLMSSP_NEGOTIATE_128) { TRACE("NTLM SEALKEY(): 128-bit key (Extended session security)\n"); @@ -179,9 +197,11 @@ TRACE("NTLM SEALKEY(): 128-bit key\n"); memcpy(result, RandomSessionKey, 16); } -} - -VOID + + return TRUE; +} + +BOOLEAN MAC(ULONG flags, PCCHAR buf, ULONG buf_len, @@ -195,7 +215,8 @@ { ULONG *res_ptr; - if (flags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) { + if (flags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) + { UCHAR seal_key_ [16]; UCHAR hmac[16]; UCHAR tmp[4 + buf_len]; @@ -204,7 +225,8 @@ RC4Init(Handle, SealingKey') */ - if (flags & NTLMSSP_NEGOTIATE_DATAGRAM) { + if (flags & NTLMSSP_NEGOTIATE_DATAGRAM) + { UCHAR tmp2 [16+4]; memcpy(tmp2, seal_key, seal_key_len); *((ULONG *)(tmp2+16)) = sequence; @@ -225,7 +247,8 @@ HMAC_MD5(sign_key, sign_key_len, tmp, 4 + buf_len, hmac); - if (flags & NTLMSSP_NEGOTIATE_KEY_EXCH) { + if (flags & NTLMSSP_NEGOTIATE_KEY_EXCH) + { TRACE("NTLM MAC(): Key Exchange\n"); RC4K(seal_key_, seal_key_len, hmac, 8, result+4); } else { @@ -248,6 +271,8 @@ // Replace the first four bytes of the ciphertext with the random_pad res_ptr[1] = random_pad; // 4 bytes } + + return TRUE; } VOID @@ -324,6 +349,9 @@ pNtResponse->Flags = 0; pNtResponse->MsgWord = 0; + TRACE("%wZ %wZ %wZ %wZ %p %p %p %p %p\n", + pUserName, pPassword, pDomainName, pServerName, ChallengeToClient, + pNtResponse, pLm2Response, pUserSessionKey, pLmSessionKey); NtQuerySystemTime((PLARGE_INTEGER)&pNtResponse->TimeStamp); NtlmGenerateRandomBits(pNtResponse->ChallengeFromClient, MSV1_0_CHALLENGE_LENGTH); @@ -361,7 +389,6 @@ { HMAC_MD5_CTX ctx; - HMACMD5Init(&ctx, (PUCHAR)NtpUserSessionKey, sizeof(*NtpUserSessionKey)); HMACMD5Update(&ctx, ChallengeToClient, MSV1_0_CHALLENGE_LENGTH); HMACMD5Update(&ctx, ChallengeFromClient, MSV1_0_CHALLENGE_LENGTH); Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/ciphers.h URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/ciphers.h [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/ciphers.h [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -54,7 +54,7 @@ }MD5_CTX; /* advapi32 */ -void WINAPI MD5Init( MD5_CTX *ctx); +void WINAPI MD5Init(MD5_CTX *ctx); void WINAPI MD5Update(MD5_CTX *ctx, const unsigned char *buf, unsigned int len); void WINAPI MD5Final(MD5_CTX *ctx); Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/context.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/context.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/context.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -280,8 +280,7 @@ goto fail; } } - - }//end is datagram + } /* generate session key */ if (context->NegotiateFlags & NTLMSSP_NEGOTIATE_KEY_EXCH) @@ -329,9 +328,10 @@ OUT OPTIONAL PTimeStamp ptsExpiry) { SECURITY_STATUS ret = SEC_E_OK; - PSecBuffer InputToken1, InputToken2; - PSecBuffer OutputToken1, OutputToken2; - ULONG_PTR newContext; + PSecBuffer InputToken1, InputToken2 = NULL; + PSecBuffer OutputToken1, OutputToken2 = NULL; + SecBufferDesc BufferDesc; + ULONG_PTR newContext = 0; ULONG NegotiateFlags; UCHAR sessionKey; @@ -390,14 +390,13 @@ ret = NtlmGenerateNegotiateMessage(newContext, fContextReq, - InputToken1, OutputToken1); /* set result */ phNewContext->dwUpper = NegotiateFlags; phNewContext->dwLower = newContext; } - else /* challenge! */ + else if(phContext) /* challenge! */ { TRACE("ISC challenged!\n"); if (fContextReq & ISC_REQ_USE_SUPPLIED_CREDS) @@ -413,7 +412,6 @@ return SEC_E_INVALID_TOKEN; } } - *phNewContext = *phContext; ret = NtlmHandleChallengeMessage(phNewContext->dwLower, fContextReq, @@ -425,6 +423,11 @@ ptsExpiry, &NegotiateFlags); } + else + { + ERR("bad call to InitializeSecurityContext\n"); + goto fail; + } if(!NT_SUCCESS(ret)) { @@ -433,7 +436,6 @@ } /* build blob with the output message */ - SecBufferDesc BufferDesc; BufferDesc.ulVersion = SECBUFFER_VERSION; BufferDesc.cBuffers = 1; BufferDesc.pBuffers = OutputToken1; @@ -441,7 +443,8 @@ if(fContextReq & ISC_REQ_ALLOCATE_MEMORY) *pfContextAttr |= ISC_RET_ALLOCATED_MEMORY; - *pOutput = BufferDesc; + if(pOutput) + *pOutput = BufferDesc; return ret; @@ -455,7 +458,7 @@ if(OutputToken1 && OutputToken1->pvBuffer) NtlmFree(OutputToken1->pvBuffer); if(OutputToken2 && OutputToken2->pvBuffer) - NtlmFree(OutputToken1->pvBuffer); + NtlmFree(OutputToken2->pvBuffer); } return ret; @@ -567,8 +570,11 @@ OUT PTimeStamp ptsExpiry) { SECURITY_STATUS ret = SEC_E_OK; - PSecBuffer InputToken1, InputToken2; - PSecBuffer OutputToken1, OutputToken2; + PSecBuffer InputToken1, InputToken2 = NULL; + PSecBuffer OutputToken1, OutputToken2 = NULL; + SecBufferDesc BufferDesc; + USER_SESSION_KEY sessionKey; + ULONG userflags; TRACE("AcceptSecurityContext %p %p %p %lx %lx %p %p %p %p\n", phCredential, phContext, pInput, fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr, ptsExpiry); @@ -591,7 +597,7 @@ FALSE); if(!ret) { - ERR("Failed to get input token!\n"); + ERR("Failed to get input token 2!\n"); //return SEC_E_INVALID_TOKEN; } @@ -628,8 +634,6 @@ else { *phNewContext = *phContext; - USER_SESSION_KEY sessionKey; - ULONG userflags; TRACE("phNewContext->dwLower %lx\n", phNewContext->dwLower); ret = NtlmHandleAuthenticateMessage(phNewContext->dwLower, fContextReq, @@ -648,7 +652,6 @@ } /* build blob with the output message */ - SecBufferDesc BufferDesc; BufferDesc.ulVersion = SECBUFFER_VERSION; BufferDesc.cBuffers = 1; BufferDesc.pBuffers = OutputToken1; Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/credentials.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/credentials.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/credentials.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -135,18 +135,29 @@ ULONG ulAttribute, PVOID pBuffer) { + PNTLMSSP_CREDENTIAL credentials = NULL; + PSecPkgContext_NamesW credname; SECURITY_STATUS ret; TRACE("(%p, %lx, %p)\n", phCredential, ulAttribute, pBuffer); - if(ulAttribute == SECPKG_ATTR_NAMES) - { - FIXME("SECPKG_CRED_ATTR_NAMES: stub\n"); + credentials = NtlmReferenceCredential(phCredential->dwLower); + + switch(ulAttribute) + { + case SECPKG_ATTR_NAMES: + credname = (PSecPkgContext_NamesW) pBuffer; + credname->sUserName = _wcsdup(credentials->UserName.Buffer); + ret = SEC_E_OK; + break; + default: + FIXME("QueryCredentialsAttributesW(%p, %lx, %p) Unimplemented\n", + phCredential, ulAttribute, pBuffer); ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - ret = SEC_E_UNSUPPORTED_FUNCTION; - + break; + } + + NtlmDereferenceCredential(phCredential->dwLower); return ret; } @@ -156,18 +167,23 @@ IN ULONG ulAttribute, OUT PVOID pBuffer) { + //PNTLMSSP_CREDENTIAL credentials = NULL; SECURITY_STATUS ret; TRACE("(%p, %lx, %p)\n", phCredential, ulAttribute, pBuffer); - if(ulAttribute == SECPKG_ATTR_NAMES) - { - FIXME("SECPKG_CRED_ATTR_NAMES: stub\n"); + //credentials = NtlmReferenceCredential(phCredential->dwLower); + + switch(ulAttribute) + { + default: + FIXME("QueryCredentialsAttributesA(%p, %lx, %p) Unimplemented\n", + phCredential, ulAttribute, pBuffer); ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - ret = SEC_E_UNSUPPORTED_FUNCTION; - + break; + } + + //NtlmDereferenceCredential(phCredential->dwLower); return ret; } @@ -203,8 +219,7 @@ RtlInitUnicodeString(&domain, NULL); RtlInitUnicodeString(&password, NULL); - //if(fCredentialUse == SECPKG_CRED_OUTBOUND) - if(pAuthData) + if(fCredentialUse == SECPKG_CRED_OUTBOUND && pAuthData) { PSEC_WINNT_AUTH_IDENTITY_W auth_data = pAuthData; @@ -265,7 +280,6 @@ /* FIXME: LOOKUP STORED CREDENTIALS!!! */ /* we need to build a credential */ - /* refactor: move into seperate function */ if(!foundCred) { cred = (PNTLMSSP_CREDENTIAL)NtlmAllocate(sizeof(NTLMSSP_CREDENTIAL)); @@ -305,8 +319,8 @@ phCredential->dwUpper = credFlags; phCredential->dwLower = (ULONG_PTR)cred; - //*ptsExpiry->HighPart = 0x7FFFFF36; - //*ptsExpiry->LowPart = 0xD5969FFF; + ptsExpiry->HighPart = 0x7FFFFF36; + ptsExpiry->LowPart = 0xD5969FFF; /* free strings as we used recycled credentials */ @@ -438,7 +452,7 @@ if(!phCredential) return SEC_E_INVALID_HANDLE; - NtlmDereferenceCredential((ULONG_PTR)phCredential->dwLower); + NtlmDereferenceCredential(phCredential->dwLower); phCredential = NULL; return SEC_E_OK; Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/crypt.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/crypt.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/crypt.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -22,14 +22,17 @@ #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(ntlm); +#ifdef USE_CRYPTOAPI HCRYPTPROV Prov; +#endif PVOID LockedMemoryPtr = NULL; ULONG LockedMemorySize = 0; + BOOL NtlmInitializeRNG(VOID) { - BOOL ret; - + BOOL ret = TRUE; +#ifdef USE_CRYPTOAPI /* prevent double initialization */ if(Prov) return TRUE; @@ -42,27 +45,33 @@ if(!ret) ERR("CryptAcquireContext failed with %x.\n",GetLastError()); +#endif return ret; } VOID NtlmTerminateRNG(VOID) { +#ifdef USE_CRYPTOAPI if(Prov) { CryptReleaseContext(Prov,0); Prov = 0; } +#endif } NTSTATUS NtlmGenerateRandomBits(VOID *Bits, ULONG Size) { +#ifdef USE_CRYPTOAPI if(CryptGenRandom(Prov, Size, (BYTE*)Bits)) return STATUS_SUCCESS; - - //return STATUS_UNSUCCESSFUL; - return STATUS_SUCCESS; +#else + if(RtlGenRandom(Bits, Size)) + return STATUS_SUCCESS; +#endif + return STATUS_UNSUCCESSFUL; } BOOL Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/debug.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/debug.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/debug.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -118,7 +118,7 @@ rgbLine[cbLine++] = 0; TRACE("%s\n", rgbLine); } -} // end PrintHexDump +} void NtlmPrintAvPairs(const PVOID Buffer) Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/dllmain.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/dllmain.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/dllmain.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -26,21 +26,15 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { - TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved); + TRACE("DllMain(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved); switch (fdwReason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hinstDLL); NtlmInitializeGlobals(); - - /* rsaehn has still not registered its crypto providers */ - if(!SetupIsActive()) - { - //REACTOS BUG: even after 2nd stage crypto providers are not available! - NtlmInitializeRNG(); - NtlmInitializeProtectedMemory(); - } + NtlmInitializeRNG(); + NtlmInitializeProtectedMemory(); NtlmCredentialInitialize(); NtlmContextInitialize(); break; Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/messages.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/messages.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/messages.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -17,6 +17,7 @@ * */ #include "ntlmssp.h" +#include "ciphers.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(ntlm); @@ -27,34 +28,74 @@ SECURITY_STATUS SEC_ENTRY EncryptMessage(PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo) { - SECURITY_STATUS ret = SEC_E_UNSUPPORTED_FUNCTION; - //int token_idx, data_idx; + SECURITY_STATUS ret = SEC_E_OK; + PSecBuffer data_buffer = NULL; + PSecBuffer signature_buffer = NULL; + UCHAR digest[16], checksum[8], *signature; + UINT index, length, version = 1; + PNTLMSSP_CONTEXT context; + HMAC_MD5_CTX hmac; + void* data; - TRACE("(%p %d %p %d)\n", phContext, fQOP, pMessage, MessageSeqNo); + ERR("EncryptMessage(%p %d %p %d)\n", phContext, fQOP, pMessage, MessageSeqNo); + + if(fQOP) + FIXME("Ignoring fQOP\n"); if(!phContext) return SEC_E_INVALID_HANDLE; - if(fQOP) - FIXME("Ignoring fQOP\n"); - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) return SEC_E_INVALID_TOKEN; - //if((token_idx = GetTokenBufferIndex(pMessage)) == -1) - // return SEC_E_INVALID_TOKEN; + /* get context, need to free it later! */ + context = NtlmReferenceContext(phContext->dwLower); - //if((data_idx = GetDataBufferIndex(pMessage)) ==-1 ) - // return SEC_E_INVALID_TOKEN; + TRACE("pMessage->cBuffers %d\n", pMessage->cBuffers); + /* extract data and signature buffers */ + for (index = 0; index < (int) pMessage->cBuffers; index++) + { + TRACE("pMessage->pBuffers[index].BufferType %d\n", pMessage->pBuffers[index].BufferType); + if (pMessage->pBuffers[index].BufferType == SECBUFFER_DATA) + data_buffer = &pMessage->pBuffers[index]; + else if (pMessage->pBuffers[index].BufferType == SECBUFFER_TOKEN) + signature_buffer = &pMessage->pBuffers[index]; + } - //if(pMessage->pBuffers[token_idx].cbBuffer < 16) - // return SEC_E_BUFFER_TOO_SMALL; + if (!data_buffer || !signature_buffer) + { + ERR("No data or tokens provided!\n"); + ret = SEC_E_INVALID_TOKEN; + goto exit; + } - FIXME("EncryptMessage Unimplemented\n"); + /* Copy original data buffer */ + length = data_buffer->cbBuffer; + data = NtlmAllocate(length); + memcpy(data, data_buffer->pvBuffer, length); + /* Compute the HMAC-MD5 hash of ConcatenationOf(seq_num,data) using the client signing key */ + HMACMD5Init(&hmac, context->ClientSigningKey, sizeof(context->ServerSigningKey)); + HMACMD5Update(&hmac, (void*) &(MessageSeqNo), sizeof(MessageSeqNo)); + HMACMD5Update(&hmac, data, length); + HMACMD5Final(&hmac, digest); + + /* Encrypt message using with RC4, result overwrites original buffer */ + rc4_crypt(context->SendSealKey, data_buffer->pvBuffer, data, length); + NtlmFree(data); + + /* RC4-encrypt first 8 bytes of digest */ + rc4_crypt(context->SendSealKey, checksum, digest, 8); + signature = (UCHAR*) signature_buffer->pvBuffer; + + /* Concatenate version, ciphertext and sequence number to build signature */ + memcpy(signature, (void*) &version, sizeof(version)); + memcpy(&signature[4], (void*) checksum, sizeof(checksum)); + memcpy(&signature[12], (void*) &(MessageSeqNo), sizeof(MessageSeqNo)); + context->SentSequenceNum++; + +exit: + NtlmDereferenceContext(phContext->dwLower); return ret; } @@ -65,30 +106,84 @@ SECURITY_STATUS SEC_ENTRY DecryptMessage(PCtxtHandle phContext, PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP) { - //int token_idx, data_idx; - SECURITY_STATUS ret = SEC_E_UNSUPPORTED_FUNCTION; + SECURITY_STATUS ret = SEC_E_OK; + PNTLMSSP_CONTEXT context; + ULONG index, length; + HMAC_MD5_CTX hmac; + UINT version = 1; + UCHAR digest[16], expected_signature[16], checksum[8]; + PSecBuffer data_buffer = NULL, signature = NULL; + PVOID data; TRACE("(%p %p %d %p)\n", phContext, pMessage, MessageSeqNo, pfQOP); + /* sanity checks */ if(!phContext) return SEC_E_INVALID_HANDLE; - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) return SEC_E_INVALID_TOKEN; - //if((token_idx = GetTokenBufferIndex(pMessage)) == -1) - // return SEC_E_INVALID_TOKEN; + /* get context */ + context = NtlmReferenceContext(phContext->dwLower); - //if((data_idx = GetDataBufferIndex(pMessage)) ==-1) - // return SEC_E_INVALID_TOKEN; + /* extract data and signature buffers */ + for (index = 0; index < (int) pMessage->cBuffers; index++) + { + if (pMessage->pBuffers[index].BufferType == SECBUFFER_DATA) + data_buffer = &pMessage->pBuffers[index]; + else if (pMessage->pBuffers[index].BufferType == SECBUFFER_TOKEN) + signature = &pMessage->pBuffers[index]; + } - //if(pMessage->pBuffers[token_idx].cbBuffer < 16) - // return SEC_E_BUFFER_TOO_SMALL; + /* verify we got needed buffers */ + if (!data_buffer || !signature) + { + ERR("No data or tokens provided!\n"); + ret = SEC_E_INVALID_TOKEN; + goto exit; + } - FIXME("DecryptMessage Unimplemented\n"); + + if(signature->cbBuffer < 16) + { + ERR("Signature buffer too small!\n"); + ret = SEC_E_BUFFER_TOO_SMALL; + goto exit; + } + + /* Copy original data buffer */ + length = data_buffer->cbBuffer; + data = NtlmAllocate(length); + memcpy(data, data_buffer->pvBuffer, length); + /* Decrypt message using with RC4 */ + rc4_crypt(context->RecvSealKey, data_buffer->pvBuffer, data, length); + + /* Compute the HMAC-MD5 hash of ConcatenationOf(seq_num,data) using the client signing key */ + HMACMD5Init(&hmac, context->ServerSigningKey, sizeof(context->ServerSigningKey)); + HMACMD5Update(&hmac, (UCHAR*) &(MessageSeqNo), sizeof(MessageSeqNo)); + HMACMD5Update(&hmac, data_buffer->pvBuffer, data_buffer->cbBuffer); + HMACMD5Final(&hmac, digest); + NtlmFree(data); + + /* RC4-encrypt first 8 bytes of digest */ + rc4_crypt(context->RecvSealKey, digest, checksum, 8); + + /* Concatenate version, ciphertext and sequence number to build signature */ + memcpy(expected_signature, (void*) &version, 4); + memcpy(&expected_signature[4], (void*) checksum, 4); + memcpy(&expected_signature[12], (void*) &(MessageSeqNo), 4); + context->RecvSequenceNum++; + + if (memcmp(signature->pvBuffer, expected_signature, sizeof(expected_signature)) != 0) + { + /* signature verification failed! */ + ERR("signature verification failed, something nasty is going on!\n"); + ret = SEC_E_MESSAGE_ALTERED; + } + +exit: + NtlmDereferenceContext(phContext->dwLower); return ret; } Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -25,11 +25,11 @@ /* globals */ CRITICAL_SECTION GlobalCritSect; /* use to read/write global state */ -NTLM_MODE NtlmMode = NtlmUserMode; /* FIXME */ +NTLM_MODE NtlmMode = NtlmUserMode; /* FIXME: No LSA mode support */ UNICODE_STRING NtlmComputerNameString; UNICODE_STRING NtlmDomainNameString; UNICODE_STRING NtlmDnsNameString; -UNICODE_STRING NtlmAvTargetInfo; // contains AV pairs with local info +UNICODE_STRING NtlmAvTargetInfo; OEM_STRING NtlmOemComputerNameString; OEM_STRING NtlmOemDomainNameString; OEM_STRING NtlmOemDnsNameString; @@ -41,7 +41,7 @@ NtlmInitializeGlobals(VOID) { NTSTATUS status = STATUS_SUCCESS; - //LPWKSTA_USER_INFO_1 pBuf = NULL; + LPWKSTA_USER_INFO_1 pBuf = NULL; WCHAR compName[CNLEN + 1], domName[DNLEN+1], dnsName[256]; ULONG compNamelen = sizeof(compName), dnsNamelen = sizeof(dnsName); PMSV1_0_AV_PAIR pAvPairs; @@ -58,24 +58,24 @@ if (!GetComputerNameExW(ComputerNameDnsFullyQualified, dnsName, &dnsNamelen)) { dnsName[0] = L'\0'; + ERR("could not get dns name!\n"); + } + TRACE("%s\n",debugstr_w(dnsName)); + + /* FIXME: this still does not match what msv1_0 returns */ + if (!(NERR_Success == NetWkstaUserGetInfo(0, 1, (LPBYTE*)&pBuf))) + { + wcscpy(domName, L"WORKGROUP"); ERR("could not get domain name!\n"); } - TRACE("%s\n",debugstr_w(dnsName)); - - /* FIXME: this still does not match what msv1_0 returns */ - // if (!(NERR_Success == NetWkstaUserGetInfo(0, 1, (LPBYTE*)&pBuf))) - //{ - wcscpy(domName, L"WORKGROUP\0"); - FIXME("how to get domain name!?\n"); - //} - //else - //{ - // wcscpy(domName, pBuf->wkui1_logon_domain); - //} - - //if (pBuf != NULL) - // NetApiBufferFree(pBuf); - TRACE("%s\n",debugstr_w(domName)); + else + { + wcscpy(domName, pBuf->wkui1_logon_domain); + } + + if (pBuf != NULL) + NetApiBufferFree(pBuf); + ERR("%s\n",debugstr_w(domName)); RtlCreateUnicodeString(&NtlmComputerNameString, compName); RtlCreateUnicodeString(&NtlmDnsNameString, dnsName); @@ -101,9 +101,8 @@ { ERR("could not get process token!!\n"); } - + //FIX ME: This is broken /* init global target AV pairs */ - RtlInitUnicodeString(&NtlmAvTargetInfo, NULL); AvPairsLen = NtlmDomainNameString.Length + //fix me: domain controller name NtlmComputerNameString.Length + //computer name @@ -126,6 +125,8 @@ NtlmAvlAdd(pAvPairs, MsvAvDnsComputerName, &NtlmDnsNameString, AvPairsLen); NtlmAvTargetInfo.Length = (USHORT)NtlmAvlLen(pAvPairs, AvPairsLen); + ERR("NtlmAvTargetInfo %S\n", NtlmAvTargetInfo.Buffer); + NtlmPrintAvPairs(pAvPairs); return status; } Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.h URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.h [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/ntlmssp.h [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -110,19 +110,30 @@ typedef struct _NTLMSSP_CONTEXT { LIST_ENTRY Entry; - LARGE_INTEGER StartTime;//context creation time + LARGE_INTEGER StartTime; BOOL isServer; BOOL isLocal; - ULONG Timeout;//how long context is valid pre-authentication + ULONG Timeout; ULONG RefCount; ULONG NegotiateFlags; ULONG ContextFlags; NTLMSSP_CONTEXT_STATE State; PNTLMSSP_CREDENTIAL Credential; - UCHAR Challenge[MSV1_0_CHALLENGE_LENGTH]; //ChallengeSent - UCHAR SessionKey[MSV1_0_USER_SESSION_KEY_LENGTH]; //LSA + UCHAR Challenge[MSV1_0_CHALLENGE_LENGTH]; + UCHAR SessionKey[MSV1_0_USER_SESSION_KEY_LENGTH]; HANDLE ClientToken; ULONG ProcId; + + /* message support */ + int SentSequenceNum; + int RecvSequenceNum; + struct _rc4_key* SendSealKey; + struct _rc4_key* RecvSealKey; + UCHAR ClientSigningKey[16]; + UCHAR ClientSealingKey[16]; + UCHAR ServerSigningKey[16]; + UCHAR ServerSealingKey[16]; + UCHAR MessageIntegrityCheck[16]; } NTLMSSP_CONTEXT, *PNTLMSSP_CONTEXT; /* private functions */ Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -25,7 +25,6 @@ SECURITY_STATUS NtlmGenerateNegotiateMessage(IN ULONG_PTR Context, IN ULONG ContextReq, - IN PSecBuffer InputToken, OUT PSecBuffer OutputToken) { PNTLMSSP_CONTEXT context = (PNTLMSSP_CONTEXT)Context; @@ -69,18 +68,18 @@ return SEC_E_INSUFFICIENT_MEMORY; } - /* allocate a negotiate message */ - if(!(message = (PNEGOTIATE_MESSAGE) NtlmAllocate(messageSize))) - return SEC_E_INSUFFICIENT_MEMORY; + /* use allocated memory */ + message = (PNEGOTIATE_MESSAGE) OutputToken->pvBuffer; + offset = (ULONG_PTR)(message+1); /* build message */ - strcpy(message->Signature, NTLMSSP_SIGNATURE); + strncpy(message->Signature, NTLMSSP_SIGNATURE, sizeof(NTLMSSP_SIGNATURE)); message->MsgType = NtlmNegotiate; message->NegotiateFlags = context->NegotiateFlags; TRACE("nego message %p size %lu\n", message, messageSize); - - offset = (ULONG_PTR)(message+1); + TRACE("context %p context->NegotiateFlags:\n",context); + NtlmPrintNegotiateFlags(message->NegotiateFlags); /* local connection */ if((!cred->DomainName.Buffer && !cred->UserName.Buffer && @@ -108,20 +107,69 @@ blobBuffer[1].Offset = offset+1; } - /* zero struct */ + /* zero version struct */ memset(&message->Version, 0, sizeof(NTLM_WINDOWS_VERSION)); - /* send it back */ - memcpy(OutputToken->pvBuffer, message, messageSize); + /* set state */ + context->State = NegotiateSent; + return SEC_I_CONTINUE_NEEDED; +} + +SECURITY_STATUS +NtlmGenerateChallengeMessage(IN PNTLMSSP_CONTEXT Context, + IN PNTLMSSP_CREDENTIAL Credentials, + IN UNICODE_STRING TargetName, + IN ULONG MessageFlags, + OUT PSecBuffer OutputToken) +{ + PCHALLENGE_MESSAGE chaMessage = NULL; + ULONG messageSize, offset; + + /* compute message size */ + messageSize = sizeof(CHALLENGE_MESSAGE) + NtlmAvTargetInfo.Length; + if(TargetName.Length > 0) + messageSize += TargetName.Length; + + ERR("generating chaMessage of size %lu\n", messageSize); + + /* + * according to tests ntlm does not listen to ASC_REQ_ALLOCATE_MEMORY + * or lack thereof, furthermore the buffer size is always NTLM_MAX_BUF + */ + OutputToken->pvBuffer = NtlmAllocate(NTLM_MAX_BUF); OutputToken->cbBuffer = messageSize; - context->State = NegotiateSent; - - TRACE("context %p context->NegotiateFlags:\n",context); - NtlmPrintNegotiateFlags(message->NegotiateFlags); - - /* free resources */ - NtlmFree(message); - + + /* check allocation */ + if(!OutputToken->pvBuffer) + return SEC_E_INSUFFICIENT_MEMORY; + + /* use allocated memory */ + chaMessage = (PCHALLENGE_MESSAGE)OutputToken->pvBuffer; + + /* build message */ + strncpy(chaMessage->Signature, NTLMSSP_SIGNATURE, sizeof(NTLMSSP_SIGNATURE)); + chaMessage->MsgType = NtlmChallenge; + chaMessage->NegotiateFlags = Context->NegotiateFlags; + chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_NTLM; + + /* generate server challenge */ + NtlmGenerateRandomBits(chaMessage->ServerChallenge, MSV1_0_CHALLENGE_LENGTH); + memcpy(Context->Challenge, chaMessage->ServerChallenge, MSV1_0_CHALLENGE_LENGTH); + + /* point to the end of chaMessage */ + offset = (ULONG_PTR)(chaMessage+messageSize); + + /* set target information */ + ERR("set target information chaMessage %p to %S, len %d, offset %d\n", chaMessage, TargetName.Buffer, TargetName.Length, &offset); + NtlmUnicodeStringToBlob((PVOID)chaMessage, &TargetName, &chaMessage->TargetName, &offset); + + //ERR("set target information %p to avl %S, %d, %d\n", chaMessage, NtlmAvTargetInfo.Buffer, NtlmAvTargetInfo.Length, offset); + //NtlmPrintAvPairs(&NtlmAvTargetInfo); + //NtlmUnicodeStringToBlob((PVOID)chaMessage, &NtlmAvTargetInfo, &chaMessage->TargetInfo, &offset); + chaMessage->NegotiateFlags |= MessageFlags; + + /* set state */ + Context->State = ChallengeSent; return SEC_I_CONTINUE_NEEDED; } @@ -142,8 +190,7 @@ PNTLMSSP_CONTEXT context = NULL; UNICODE_STRING targetName; OEM_STRING OemDomainName, OemWorkstationName; - ULONG targetFlags = 0; - BOOLEAN isUnicode; + ULONG negotiateFlags = 0; TRACE("NtlmHandleNegotiateMessage hContext %lx\n", hContext); if(!(context = NtlmAllocateContext())) @@ -154,7 +201,6 @@ } hContext = (ULONG_PTR)context; - TRACE("NtlmHandleNegotiateMessage hContext %lx\n", hContext); /* InputToken should contain a negotiate message */ if(InputToken->cbBuffer > NTLM_MAX_BUF || @@ -259,18 +305,16 @@ if (negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY || negoMessage->NegotiateFlags & NTLMSSP_REQUEST_TARGET) { - targetFlags |= NTLMSSP_TARGET_TYPE_SERVER | NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_TARGET_INFO; + negotiateFlags |= NTLMSSP_TARGET_TYPE_SERVER | NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_TARGET_INFO; if (negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_UNICODE) { - isUnicode = TRUE; - targetFlags |= NTLMSSP_NEGOTIATE_UNICODE; + negotiateFlags |= NTLMSSP_NEGOTIATE_UNICODE; RtlInitUnicodeString(&targetName, NtlmComputerNameString.Buffer); } else if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_OEM) { - isUnicode = FALSE; - targetFlags |= NTLMSSP_NEGOTIATE_OEM; + negotiateFlags |= NTLMSSP_NEGOTIATE_OEM; RtlInitUnicodeString(&targetName, (PWCHAR)&NtlmOemComputerNameString.Buffer); } else @@ -281,87 +325,6 @@ } } - /* create a challenge message */ - PCHALLENGE_MESSAGE chaMessage = NULL; - ULONG messageSize = sizeof(CHALLENGE_MESSAGE)+ targetName.Length + 1 + NtlmAvTargetInfo.Length; - ULONG offset; - - /* ntlm does not listen to ASC_REQ_ALLOCATE_MEMORY or lack thereof */ - /* further more the buffer size is always NTLM_MAX_BUF */ - /* allocate output buffer */ - OutputToken->pvBuffer = NtlmAllocate(NTLM_MAX_BUF); - OutputToken->cbBuffer = messageSize; - - if(!OutputToken->pvBuffer) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - goto exit; - } - - /* allocate message */ - if (!(chaMessage = (PCHALLENGE_MESSAGE)NtlmAllocate(messageSize))) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - goto exit; - } - - TRACE("message %p size %lu\n", chaMessage, messageSize); - - /* build message */ - strcpy(chaMessage->Signature, NTLMSSP_SIGNATURE); - chaMessage->MsgType = NtlmChallenge; - chaMessage->NegotiateFlags = context->NegotiateFlags; - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_NTLM; - - /* generate challenge */ - NtlmGenerateRandomBits(chaMessage->ServerChallenge, MSV1_0_CHALLENGE_LENGTH); - memcpy(context->Challenge, chaMessage->ServerChallenge, MSV1_0_CHALLENGE_LENGTH); - - offset = (ULONG_PTR)(chaMessage+1); - - if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) - { - negoMessage->NegotiateFlags &= ~NTLMSSP_NEGOTIATE_LM_KEY; - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY; - } - else if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_LM_KEY) - { - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_LM_KEY; - } - - if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN) - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN; - - if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_SIGN) - { - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_SIGN; - *pContextAttr |= (ASC_RET_SEQUENCE_DETECT | ASC_RET_REPLAY_DETECT); - context->ContextFlags |= (ASC_RET_SEQUENCE_DETECT | ASC_RET_REPLAY_DETECT); - } - - if (negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_SEAL) - { - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_SEAL; - *pContextAttr |= ASC_RET_CONFIDENTIALITY; - context->ContextFlags |= ASC_RET_CONFIDENTIALITY; - } - - if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_KEY_EXCH) - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_KEY_EXCH; - - /* client requested encryption */ - if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_128) - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_128; - else if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_56) - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_56; - - if(negoMessage->NegotiateFlags & NTLMSSP_REQUEST_INIT_RESP) - { - chaMessage->NegotiateFlags |= NTLMSSP_REQUEST_INIT_RESP; - *pContextAttr |= ASC_RET_IDENTIFY; - context->ContextFlags |= ASC_RET_IDENTIFY; - } - /* check for local call */ if((negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED) && (negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED)) @@ -369,30 +332,70 @@ NtlmBlobToUnicodeString(InputToken, negoMessage->OemDomainName, (PUNICODE_STRING)&OemDomainName); NtlmBlobToUnicodeString(InputToken, negoMessage->OemWorkstationName, (PUNICODE_STRING)&OemWorkstationName); - if (RtlEqualString(&OemWorkstationName, &NtlmOemComputerNameString, FALSE)&& + if (RtlEqualString(&OemWorkstationName, &NtlmOemComputerNameString, FALSE) && RtlEqualString(&OemDomainName, &NtlmOemDomainNameString, FALSE)) { TRACE("local negotiate detected!\n"); - chaMessage->NegotiateFlags |= NTLMSSP_NEGOTIATE_LOCAL_CALL; + negotiateFlags |= NTLMSSP_NEGOTIATE_LOCAL_CALL; } } - NtlmUnicodeStringToBlob((PVOID)chaMessage, &targetName, &chaMessage->TargetName, &offset); - NtlmUnicodeStringToBlob((PVOID)chaMessage, &NtlmAvTargetInfo, &chaMessage->TargetInfo, &offset); - chaMessage->NegotiateFlags |= targetFlags; - - memcpy(OutputToken->pvBuffer, chaMessage, messageSize); - OutputToken->cbBuffer = messageSize; - context->State = ChallengeSent; - ret = SEC_I_CONTINUE_NEEDED; + /* compute negotiate message flags */ + if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY) + { + negoMessage->NegotiateFlags &= ~NTLMSSP_NEGOTIATE_LM_KEY; + negotiateFlags |= NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY; + } + else if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_LM_KEY) + { + negotiateFlags |= NTLMSSP_NEGOTIATE_LM_KEY; + } + + if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN) + negotiateFlags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN; + + if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_SIGN) + { + *pContextAttr |= (ASC_RET_SEQUENCE_DETECT | ASC_RET_REPLAY_DETECT); + context->ContextFlags |= (ASC_RET_SEQUENCE_DETECT | ASC_RET_REPLAY_DETECT); + negotiateFlags |= NTLMSSP_NEGOTIATE_SIGN; + } + + if (negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_SEAL) + { + *pContextAttr |= ASC_RET_CONFIDENTIALITY; + context->ContextFlags |= ASC_RET_CONFIDENTIALITY; + negotiateFlags |= NTLMSSP_NEGOTIATE_SEAL; + } + + if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_KEY_EXCH) + negotiateFlags |= NTLMSSP_NEGOTIATE_KEY_EXCH; + + /* client requested encryption */ + if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_128) + negotiateFlags |= NTLMSSP_NEGOTIATE_128; + else if(negoMessage->NegotiateFlags & NTLMSSP_NEGOTIATE_56) + negotiateFlags |= NTLMSSP_NEGOTIATE_56; + + if(negoMessage->NegotiateFlags & NTLMSSP_REQUEST_INIT_RESP) + { + *pContextAttr |= ASC_RET_IDENTIFY; + context->ContextFlags |= ASC_RET_IDENTIFY; + negotiateFlags |= NTLMSSP_REQUEST_INIT_RESP; + } + + ret = NtlmGenerateChallengeMessage(context, + cred, + targetName, + negotiateFlags, + OutputToken); exit: - //if(chaMessage) NtlmFree(chaMessage); - //if(negoMessage) NtlmFree(negoMessage); - //if(cred) NtlmDereferenceCredential((ULONG_PTR)cred); - //if(targetName.Buffer) NtlmFree(targetName.Buffer); - //if(OemDomainName.Buffer) NtlmFree(OemDomainName.Buffer); - //if(OemWorkstationName.Buffer) NtlmFree(OemWorkstationName.Buffer); + if(negoMessage) NtlmFree(negoMessage); + if(cred) NtlmDereferenceCredential((ULONG_PTR)cred); + if(targetName.Buffer) NtlmFree(targetName.Buffer); + if(OemDomainName.Buffer) NtlmFree(OemDomainName.Buffer); + if(OemWorkstationName.Buffer) NtlmFree(OemWorkstationName.Buffer); return ret; } @@ -413,6 +416,19 @@ PCHALLENGE_MESSAGE challenge = NULL; PNTLMSSP_CREDENTIAL cred = NULL; BOOLEAN isUnicode; + UNICODE_STRING ServerName; + MSV1_0_NTLM3_RESPONSE NtResponse; + LM2_RESPONSE Lm2Response; + USER_SESSION_KEY UserSessionKey; + LM_SESSION_KEY LmSessionKey; + + PAUTHENTICATE_MESSAGE authmessage = NULL; + ULONG_PTR offset; + UNICODE_STRING NtResponseString; + UNICODE_STRING LmResponseString; + UNICODE_STRING UserSessionKeyString; + UNICODE_STRING LmSessionKeyString; + ULONG messageSize; TRACE("NtlmHandleChallengeMessage hContext %lx\n", hContext); /* get context */ @@ -561,27 +577,32 @@ ERR("NTLMSSP_NEGOTIATE_LOCAL_CALL set!\n"); /* extract target info */ - UNICODE_STRING ServerName; - if(context->NegotiateFlags & NTLMSSP_NEGOTIATE_TARGET_INFO) { - /* wtf? shouldnt this contain AV pairs? */ - ret = NtlmBlobToUnicodeString(InputToken1, - challenge->TargetInfo, - &ServerName); - if(!NT_SUCCESS(ret)) - { - ERR("could not get target info!\n"); - goto fail; - } - } - else + ERR("NTLMSSP_NEGOTIATE_TARGET_INFO\n"); + //PMSV1_0_AV_PAIR pAvPair; + //pAvPair = (PMSV1_0_AV_PAIR)challenge->TargetInfo; + + //PVOID ptr = ((PUCHAR)InputToken1->pvBuffer + challenge->TargetInfo.Offset); + //NtlmPrintAvPairs(ptr); + //NtlmPrintHexDump(InputToken1->pvBuffer, InputToken1->cbBuffer); + + //NtlmAvlGet(pAvPair, MsvAvNbDomainName, GetRespRequest->ServerName.Length) + + //if(!NT_SUCCESS(ret)) + //{ + // ERR("could not get target info!\n"); + // goto fail; + //} + } + //else { /* spec: "A server that is a member of a domain returns the domain of which it * is a member, and a server that is not a member of a domain returns * the server name." how to tell?? */ ret = NtlmBlobToUnicodeString(InputToken1, - challenge->TargetName, + challenge->TargetInfo, + //challenge->TargetName, &ServerName); if(!NT_SUCCESS(ret)) { @@ -592,20 +613,15 @@ FIXME("convert to unicode!\n"); } - - MSV1_0_NTLM3_RESPONSE NtResponse; - LM2_RESPONSE Lm2Response; - USER_SESSION_KEY UserSessionKey; - LM_SESSION_KEY LmSessionKey; - if(!(cred = NtlmReferenceCredential((ULONG_PTR)context->Credential))) goto fail; /* unscramble password */ NtlmUnProtectMemory(cred->Password.Buffer, cred->Password.Length); - TRACE("cred: %s %s %s\n", debugstr_w(cred->UserName.Buffer), - debugstr_w(cred->Password.Buffer), debugstr_w(cred->DomainName.Buffer)); + TRACE("cred: %s %s %s %s\n", debugstr_w(cred->UserName.Buffer), + debugstr_w(cred->Password.Buffer), debugstr_w(cred->DomainName.Buffer), + debugstr_w(ServerName.Buffer)); NtlmChallengeResponse(&cred->UserName, &cred->Password, @@ -617,32 +633,23 @@ &UserSessionKey, &LmSessionKey); - PAUTHENTICATE_MESSAGE authmessage = NULL; - ULONG_PTR offset; - - UNICODE_STRING NtResponseString; - //UNICODE_STRING LmResponseString; - UNICODE_STRING UserSessionKeyString; - UNICODE_STRING LmSessionKeyString; - -#define InitString(str, input) str.MaximumLength = str.Length = sizeof(input)*sizeof(WCHAR); str.Buffer = (WCHAR*)&input +#define InitString(str, input) str.MaximumLength = str.Length = sizeof(input); str.Buffer = (WCHAR*)&input InitString(NtResponseString, NtResponse); - //InitString(LmResponseString, Lm2Response); + InitString(LmResponseString, Lm2Response); InitString(UserSessionKeyString, UserSessionKey); InitString(LmSessionKeyString, LmSessionKey); - ULONG messageSize = sizeof(AUTHENTICATE_MESSAGE) + - ServerName.Length + cred->UserName.Length + cred->DomainName.Length + - NtResponseString.Length + UserSessionKeyString.Length + LmSessionKeyString.Length; - //LmResponseString.Length; - - if(!(authmessage = NtlmAllocate(messageSize))) + messageSize = sizeof(AUTHENTICATE_MESSAGE) + ServerName.Length + + cred->UserName.Length + cred->DomainName.Length + NtResponseString.Length + + UserSessionKeyString.Length + LmSessionKeyString.Length + LmResponseString.Length; + + if(!(authmessage = (PAUTHENTICATE_MESSAGE)NtlmAllocate(messageSize))) { ret = SEC_E_INSUFFICIENT_MEMORY; goto fail; } - strcpy(authmessage->Signature, NTLMSSP_SIGNATURE); + strncpy(authmessage->Signature, NTLMSSP_SIGNATURE, sizeof(NTLMSSP_SIGNATURE)); authmessage->MsgType = NtlmAuthenticate; offset = (ULONG_PTR)(authmessage+1); @@ -662,11 +669,13 @@ &authmessage->WorkstationName, &offset); - //if(targetinfo) - //NtlmUnicodeStringToBlob((PVOID)authmessage, - // &LmResponseString, - // &authmessage->LmChallengeResponse, - // &offset); + if (context->NegotiateFlags & NTLMSSP_NEGOTIATE_TARGET_INFO) + { + NtlmUnicodeStringToBlob((PVOID)authmessage, + &LmResponseString, + &authmessage->LmChallengeResponse, + &offset); + } NtlmUnicodeStringToBlob((PVOID)authmessage, &NtResponseString, @@ -724,7 +733,9 @@ SECURITY_STATUS ret = SEC_E_OK; PNTLMSSP_CONTEXT context = NULL; PAUTHENTICATE_MESSAGE authMessage = NULL; - BOOLEAN isUnicode; + UNICODE_STRING LmChallengeResponse, NtChallengeResponse, SessionKey; + UNICODE_STRING UserName, Workstation, DomainName; + //BOOLEAN isUnicode; TRACE("NtlmHandleAuthenticateMessage hContext %x!\n", hContext); /* get context */ @@ -735,7 +746,7 @@ } TRACE("context->State %d\n", context->State); - if(context->State != ChallengeSent || context->State != Authenticated) + if(context->State != ChallengeSent && context->State != Authenticated) { ERR("Context not in correct state!\n"); ret = SEC_E_OUT_OF_SEQUENCE; @@ -802,12 +813,12 @@ if(context->NegotiateFlags & NTLMSSP_NEGOTIATE_UNICODE) { context->NegotiateFlags &= ~NTLMSSP_NEGOTIATE_OEM; - isUnicode = TRUE; + //isUnicode = TRUE; } else if(context->NegotiateFlags & NTLMSSP_NEGOTIATE_OEM) { context->NegotiateFlags &= ~NTLMSSP_NEGOTIATE_UNICODE; - isUnicode = FALSE; + //isUnicode = FALSE; } else { @@ -816,9 +827,6 @@ ret = SEC_E_INVALID_TOKEN; goto fail; } - - UNICODE_STRING LmChallengeResponse, NtChallengeResponse, SessionKey; - UNICODE_STRING UserName, Workstation, DomainName; if(!NT_SUCCESS(NtlmBlobToUnicodeString(InputToken, authMessage->LmChallengeResponse, &LmChallengeResponse))) Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.h URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.h [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/protocol.h [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -1,24 +1,24 @@ /* - * Copyright 2011 Samuel Serapión - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - */ +* Copyright 2011 Samuel Serapión +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2.1 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, write to the Free Software +* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA +* +*/ /* see "NT LAN Manager (NTLM) Authentication Protocol Specification" - * [MS-NLMP] v20110504 for more details */ +* [MS-NLMP] v20110504 for more details */ /* signature */ #define NTLMSSP_SIGNATURE "NTLMSSP\0" @@ -65,6 +65,8 @@ #define NTLMSSP_REVISION_W2K3 0x0F /* basic types */ +typedef char const* PCCHAR; + typedef struct _CYPHER_BLOCK { CHAR data[8]; @@ -111,10 +113,10 @@ }NTLM_WINDOWS_VERSION, *PNTLM_WINDOWS_VERSION; /* - * Offset contains the offset from the beginning of the message to the - * actual value in the payload area. In the event of no data being sent - * Length and MaxLength should generaly be set to zero and ignored. - */ +* Offset contains the offset from the beginning of the message to the +* actual value in the payload area. In the event of no data being sent +* Length and MaxLength should generaly be set to zero and ignored. +*/ //NTLM_UNICODE_STRING_OVER_THE_WIRE typedef struct _NTLM_BLOB { @@ -161,7 +163,7 @@ ULONG NegotiateFlags; NTLM_WINDOWS_VERSION Version; BYTE MIC[16]; //doc says its ommited in nt,2k,xp,2k3 - /* payload */ + /* payload */ }AUTHENTICATE_MESSAGE, *PAUTHENTICATE_MESSAGE; typedef struct _MESSAGE_SIGNATURE @@ -172,18 +174,19 @@ ULONG Nonce; }MESSAGE_SIGNATURE, *PMESSAGE_SIGNATURE; +C_ASSERT(sizeof(MESSAGE_SIGNATURE) == 16); /* basic functions */ VOID NTOWFv1( - const PWCHAR password, - PUCHAR result); - -VOID + LPCWSTR password, + PUCHAR result); + +BOOLEAN NTOWFv2( - const PWCHAR password, - const PWCHAR user, - const PWCHAR domain, + LPCWSTR password, + LPCWSTR user, + LPCWSTR domain, PUCHAR result); VOID @@ -191,11 +194,11 @@ const PCCHAR password, PUCHAR result); -VOID +BOOLEAN LMOWFv2( - const PWCHAR password, - const PWCHAR user, - const PWCHAR domain, + LPCWSTR password, + LPCWSTR user, + LPCWSTR domain, PUCHAR result); VOID @@ -211,20 +214,20 @@ const PUCHAR server_challenge, PUCHAR key_exchange_key); -VOID +BOOLEAN SIGNKEY( const PUCHAR RandomSessionKey, BOOLEAN IsClient, PUCHAR Result); -VOID +BOOLEAN SEALKEY( ULONG flags, const PUCHAR RandomSessionKey, BOOLEAN client, PUCHAR result); -VOID +BOOLEAN MAC(ULONG flags, PCCHAR buf, ULONG buf_len, @@ -282,7 +285,6 @@ NtlmGenerateNegotiateMessage( IN ULONG_PTR hContext, IN ULONG ContextReq, - IN PSecBuffer InputToken, OUT PSecBuffer OutputToken); SECURITY_STATUS @@ -298,6 +300,14 @@ OUT PTimeStamp ptsExpiry); SECURITY_STATUS +NtlmGenerateChallengeMessage( + IN PNTLMSSP_CONTEXT Context, + IN PNTLMSSP_CREDENTIAL Credentials, + IN UNICODE_STRING TargetName, + IN ULONG MessageFlags, + OUT PSecBuffer OutputToken); + +SECURITY_STATUS NtlmHandleChallengeMessage( IN ULONG_PTR hContext, IN ULONG ContextReq, Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/sign.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/sign.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/sign.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -27,7 +27,6 @@ SECURITY_STATUS SEC_ENTRY MakeSignature(PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo) { - //int token_idx; SECURITY_STATUS ret = SEC_E_UNSUPPORTED_FUNCTION; TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, fQOP); @@ -36,15 +35,6 @@ if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) return SEC_E_INVALID_TOKEN; - - //if((token_idx = GetTokenBufferIndex(pMessage)) == -1) - // return SEC_E_INVALID_TOKEN; - - //if(pMessage->pBuffers[token_idx].cbBuffer < 16) - // return SEC_E_BUFFER_TOO_SMALL; - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); FIXME("MakeSignature unimplemented\n"); return ret; @@ -57,7 +47,6 @@ PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP) { SECURITY_STATUS ret = SEC_E_UNSUPPORTED_FUNCTION; - //int token_idx; TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP); if(!phContext) @@ -66,15 +55,6 @@ if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) return SEC_E_INVALID_TOKEN; - //if((token_idx = GetTokenBufferIndex(pMessage)) == -1) - // return SEC_E_INVALID_TOKEN; - - //if(pMessage->pBuffers[token_idx].cbBuffer < 16) - // return SEC_E_BUFFER_TOO_SMALL; - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - FIXME("VerifySignature unimplemented\n"); return ret; } Modified: branches/sspi-bringup/reactos/dll/win32/ntlmssp/util.c URL: http://svn.reactos.org/svn/reactos/branches/sspi-bringup/reactos/dll/win32/… ============================================================================== --- branches/sspi-bringup/reactos/dll/win32/ntlmssp/util.c [iso-8859-1] (original) +++ branches/sspi-bringup/reactos/dll/win32/ntlmssp/util.c [iso-8859-1] Thu Jan 5 19:53:57 2017 @@ -194,8 +194,9 @@ } /* convert blob into a string */ - OutputStr->MaximumLength = OutputStr->Length = Blob.Length; + OutputStr->MaximumLength = Blob.Length; OutputStr->Buffer = (PWSTR)((PCHAR)InputBuffer->pvBuffer) + offset; + OutputStr->Length = wcslen(OutputStr->Buffer) * sizeof(WCHAR); return SEC_E_OK; }

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2017