Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/bitmap.c

@@ -0,0 +1,617 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Bitmap Cache V2
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+#include <winpr/stream.h>
+
+#include <freerdp/log.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include "../gdi/gdi.h"
+#include "../core/graphics.h"
+
+#include "bitmap.h"
+#include "cache.h"
+
+#define TAG FREERDP_TAG("cache.bitmap")
+
+static rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index);
+static BOOL bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index,
+                             rdpBitmap* bitmap);
+
+static BOOL update_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
+{
+	rdpBitmap* bitmap = NULL;
+	rdpCache* cache = NULL;
+
+	cache = context->cache;
+
+	if (memblt->cacheId == 0xFF)
+		bitmap = offscreen_cache_get(cache->offscreen, memblt->cacheIndex);
+	else
+		bitmap = bitmap_cache_get(cache->bitmap, (BYTE)memblt->cacheId, memblt->cacheIndex);
+
+	/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
+	if (bitmap == NULL)
+		return TRUE;
+
+	memblt->bitmap = bitmap;
+	return IFCALLRESULT(TRUE, cache->bitmap->MemBlt, context, memblt);
+}
+
+static BOOL update_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
+{
+	rdpBitmap* bitmap = NULL;
+	rdpCache* cache = context->cache;
+	rdpBrush* brush = &mem3blt->brush;
+	BOOL ret = TRUE;
+
+	if (mem3blt->cacheId == 0xFF)
+		bitmap = offscreen_cache_get(cache->offscreen, mem3blt->cacheIndex);
+	else
+		bitmap = bitmap_cache_get(cache->bitmap, (BYTE)mem3blt->cacheId, mem3blt->cacheIndex);
+
+	/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
+	if (!bitmap)
+		return TRUE;
+
+	const BYTE style = WINPR_ASSERTING_INT_CAST(UINT8, brush->style);
+
+	if (brush->style & CACHED_BRUSH)
+	{
+		brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
+
+		if (!brush->data)
+			return FALSE;
+
+		brush->style = 0x03;
+	}
+
+	mem3blt->bitmap = bitmap;
+	IFCALLRET(cache->bitmap->Mem3Blt, ret, context, mem3blt);
+	brush->style = style;
+	return ret;
+}
+
+static BOOL update_gdi_cache_bitmap(rdpContext* context, const CACHE_BITMAP_ORDER* cacheBitmap)
+{
+	rdpBitmap* bitmap = NULL;
+	rdpBitmap* prevBitmap = NULL;
+	rdpCache* cache = context->cache;
+	bitmap = Bitmap_Alloc(context);
+
+	if (!bitmap)
+		return FALSE;
+
+	if (!Bitmap_SetDimensions(bitmap, WINPR_ASSERTING_INT_CAST(UINT16, cacheBitmap->bitmapWidth),
+	                          WINPR_ASSERTING_INT_CAST(UINT16, cacheBitmap->bitmapHeight)))
+		goto fail;
+
+	if (!bitmap->Decompress(context, bitmap, cacheBitmap->bitmapDataStream,
+	                        cacheBitmap->bitmapWidth, cacheBitmap->bitmapHeight,
+	                        cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
+	                        cacheBitmap->compressed, RDP_CODEC_ID_NONE))
+		goto fail;
+
+	if (!bitmap->New(context, bitmap))
+		goto fail;
+
+	prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex);
+	Bitmap_Free(context, prevBitmap);
+	return bitmap_cache_put(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex, bitmap);
+
+fail:
+	Bitmap_Free(context, bitmap);
+	return FALSE;
+}
+
+static BOOL update_gdi_cache_bitmap_v2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
+
+{
+	rdpBitmap* prevBitmap = NULL;
+	rdpCache* cache = context->cache;
+	rdpSettings* settings = context->settings;
+	rdpBitmap* bitmap = Bitmap_Alloc(context);
+
+	if (!bitmap)
+		return FALSE;
+
+	const UINT32 ColorDepth = freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
+	bitmap->key64 = ((UINT64)cacheBitmapV2->key1 | (((UINT64)cacheBitmapV2->key2) << 32));
+
+	if (!cacheBitmapV2->bitmapBpp)
+		cacheBitmapV2->bitmapBpp = ColorDepth;
+
+	if ((ColorDepth == 15) && (cacheBitmapV2->bitmapBpp == 16))
+		cacheBitmapV2->bitmapBpp = ColorDepth;
+
+	if (!Bitmap_SetDimensions(bitmap, WINPR_ASSERTING_INT_CAST(UINT16, cacheBitmapV2->bitmapWidth),
+	                          WINPR_ASSERTING_INT_CAST(UINT16, cacheBitmapV2->bitmapHeight)))
+		goto fail;
+
+	if (!bitmap->Decompress(context, bitmap, cacheBitmapV2->bitmapDataStream,
+	                        cacheBitmapV2->bitmapWidth, cacheBitmapV2->bitmapHeight,
+	                        cacheBitmapV2->bitmapBpp, cacheBitmapV2->bitmapLength,
+	                        cacheBitmapV2->compressed, RDP_CODEC_ID_NONE))
+		goto fail;
+
+	prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV2->cacheId, cacheBitmapV2->cacheIndex);
+
+	if (!bitmap->New(context, bitmap))
+		goto fail;
+
+	Bitmap_Free(context, prevBitmap);
+	return bitmap_cache_put(cache->bitmap, cacheBitmapV2->cacheId, cacheBitmapV2->cacheIndex,
+	                        bitmap);
+
+fail:
+	Bitmap_Free(context, bitmap);
+	return FALSE;
+}
+
+static BOOL update_gdi_cache_bitmap_v3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
+{
+	rdpBitmap* bitmap = NULL;
+	rdpBitmap* prevBitmap = NULL;
+	BOOL compressed = TRUE;
+	rdpCache* cache = context->cache;
+	rdpSettings* settings = context->settings;
+	BITMAP_DATA_EX* bitmapData = &cacheBitmapV3->bitmapData;
+	bitmap = Bitmap_Alloc(context);
+
+	if (!bitmap)
+		return FALSE;
+
+	const UINT32 ColorDepth = freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
+	bitmap->key64 = ((UINT64)cacheBitmapV3->key1 | (((UINT64)cacheBitmapV3->key2) << 32));
+
+	if (!cacheBitmapV3->bpp)
+		cacheBitmapV3->bpp = ColorDepth;
+
+	compressed = (bitmapData->codecID != RDP_CODEC_ID_NONE);
+
+	if (!Bitmap_SetDimensions(bitmap, WINPR_ASSERTING_INT_CAST(UINT16, bitmapData->width),
+	                          WINPR_ASSERTING_INT_CAST(UINT16, bitmapData->height)))
+		goto fail;
+
+	if (!bitmap->Decompress(context, bitmap, bitmapData->data, bitmapData->width,
+	                        bitmapData->height, bitmapData->bpp, bitmapData->length, compressed,
+	                        bitmapData->codecID))
+		goto fail;
+
+	if (!bitmap->New(context, bitmap))
+		goto fail;
+
+	prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV3->cacheId, cacheBitmapV3->cacheIndex);
+	Bitmap_Free(context, prevBitmap);
+	return bitmap_cache_put(cache->bitmap, cacheBitmapV3->cacheId, cacheBitmapV3->cacheIndex,
+	                        bitmap);
+
+fail:
+	Bitmap_Free(context, bitmap);
+	return FALSE;
+}
+
+rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index)
+{
+	rdpBitmap* bitmap = NULL;
+
+	if (id >= bitmapCache->maxCells)
+	{
+		WLog_ERR(TAG, "get invalid bitmap cell id: %" PRIu32 "", id);
+		return NULL;
+	}
+
+	if (index == BITMAP_CACHE_WAITING_LIST_INDEX)
+	{
+		index = bitmapCache->cells[id].number;
+	}
+	else if (index > bitmapCache->cells[id].number)
+	{
+		WLog_ERR(TAG, "get invalid bitmap index %" PRIu32 " in cell id: %" PRIu32 "", index, id);
+		return NULL;
+	}
+
+	bitmap = bitmapCache->cells[id].entries[index];
+	return bitmap;
+}
+
+BOOL bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index, rdpBitmap* bitmap)
+{
+	if (id > bitmapCache->maxCells)
+	{
+		WLog_ERR(TAG, "put invalid bitmap cell id: %" PRIu32 "", id);
+		return FALSE;
+	}
+
+	if (index == BITMAP_CACHE_WAITING_LIST_INDEX)
+	{
+		index = bitmapCache->cells[id].number;
+	}
+	else if (index > bitmapCache->cells[id].number)
+	{
+		WLog_ERR(TAG, "put invalid bitmap index %" PRIu32 " in cell id: %" PRIu32 "", index, id);
+		return FALSE;
+	}
+
+	bitmapCache->cells[id].entries[index] = bitmap;
+	return TRUE;
+}
+
+void bitmap_cache_register_callbacks(rdpUpdate* update)
+{
+	rdpCache* cache = NULL;
+
+	WINPR_ASSERT(update);
+	WINPR_ASSERT(update->context);
+	WINPR_ASSERT(update->context->cache);
+
+	cache = update->context->cache;
+	WINPR_ASSERT(cache);
+
+	if (!freerdp_settings_get_bool(update->context->settings, FreeRDP_DeactivateClientDecoding))
+	{
+		cache->bitmap->MemBlt = update->primary->MemBlt;
+		cache->bitmap->Mem3Blt = update->primary->Mem3Blt;
+		update->primary->MemBlt = update_gdi_memblt;
+		update->primary->Mem3Blt = update_gdi_mem3blt;
+		update->secondary->CacheBitmap = update_gdi_cache_bitmap;
+		update->secondary->CacheBitmapV2 = update_gdi_cache_bitmap_v2;
+		update->secondary->CacheBitmapV3 = update_gdi_cache_bitmap_v3;
+		update->BitmapUpdate = gdi_bitmap_update;
+	}
+}
+
+static int bitmap_cache_save_persistent(rdpBitmapCache* bitmapCache)
+{
+	rdpContext* context = bitmapCache->context;
+	rdpSettings* settings = context->settings;
+
+	const UINT32 version = freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheVersion);
+
+	if (version != 2)
+		return 0; /* persistent bitmap cache already saved in egfx channel */
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_BitmapCachePersistEnabled))
+		return 0;
+
+	const char* BitmapCachePersistFile =
+	    freerdp_settings_get_string(settings, FreeRDP_BitmapCachePersistFile);
+	if (!BitmapCachePersistFile)
+		return 0;
+
+	rdpPersistentCache* persistent = persistent_cache_new();
+
+	if (!persistent)
+		return -1;
+
+	int status = persistent_cache_open(persistent, BitmapCachePersistFile, TRUE, version);
+
+	if (status < 1)
+		goto end;
+
+	if (bitmapCache->cells)
+	{
+		for (UINT32 i = 0; i < bitmapCache->maxCells; i++)
+		{
+			BITMAP_V2_CELL* cell = &bitmapCache->cells[i];
+			for (UINT32 j = 0; j < cell->number + 1 && cell->entries; j++)
+			{
+				PERSISTENT_CACHE_ENTRY cacheEntry = { 0 };
+				rdpBitmap* bitmap = cell->entries[j];
+
+				if (!bitmap || !bitmap->key64)
+					continue;
+
+				cacheEntry.key64 = bitmap->key64;
+
+				cacheEntry.width = WINPR_ASSERTING_INT_CAST(UINT16, bitmap->width);
+				cacheEntry.height = WINPR_ASSERTING_INT_CAST(UINT16, bitmap->height);
+				const UINT64 size = 4ULL * bitmap->width * bitmap->height;
+				if (size > UINT32_MAX)
+					continue;
+				cacheEntry.size = (UINT32)size;
+				cacheEntry.flags = 0;
+				cacheEntry.data = bitmap->data;
+
+				if (persistent_cache_write_entry(persistent, &cacheEntry) < 1)
+				{
+					status = -1;
+					goto end;
+				}
+			}
+		}
+	}
+
+	status = 1;
+
+end:
+	persistent_cache_free(persistent);
+	return status;
+}
+
+rdpBitmapCache* bitmap_cache_new(rdpContext* context)
+{
+	rdpSettings* settings = NULL;
+	rdpBitmapCache* bitmapCache = NULL;
+
+	WINPR_ASSERT(context);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	bitmapCache = (rdpBitmapCache*)calloc(1, sizeof(rdpBitmapCache));
+
+	if (!bitmapCache)
+		return NULL;
+
+	const UINT32 BitmapCacheV2NumCells =
+	    freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
+	bitmapCache->context = context;
+	bitmapCache->cells = (BITMAP_V2_CELL*)calloc(BitmapCacheV2NumCells, sizeof(BITMAP_V2_CELL));
+
+	if (!bitmapCache->cells)
+		goto fail;
+	bitmapCache->maxCells = BitmapCacheV2NumCells;
+
+	for (UINT32 i = 0; i < bitmapCache->maxCells; i++)
+	{
+		const BITMAP_CACHE_V2_CELL_INFO* info =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, i);
+		BITMAP_V2_CELL* cell = &bitmapCache->cells[i];
+		UINT32 nr = info->numEntries;
+		/* allocate an extra entry for BITMAP_CACHE_WAITING_LIST_INDEX */
+		cell->entries = (rdpBitmap**)calloc((nr + 1), sizeof(rdpBitmap*));
+
+		if (!cell->entries)
+			goto fail;
+		cell->number = nr;
+	}
+
+	return bitmapCache;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	bitmap_cache_free(bitmapCache);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void bitmap_cache_free(rdpBitmapCache* bitmapCache)
+{
+	if (!bitmapCache)
+		return;
+
+	bitmap_cache_save_persistent(bitmapCache);
+
+	if (bitmapCache->cells)
+	{
+		for (UINT32 i = 0; i < bitmapCache->maxCells; i++)
+		{
+			UINT32 j = 0;
+			BITMAP_V2_CELL* cell = &bitmapCache->cells[i];
+
+			if (!cell->entries)
+				continue;
+
+			for (j = 0; j < cell->number + 1; j++)
+			{
+				rdpBitmap* bitmap = cell->entries[j];
+				Bitmap_Free(bitmapCache->context, bitmap);
+			}
+
+			free((void*)cell->entries);
+		}
+
+		free(bitmapCache->cells);
+	}
+
+	persistent_cache_free(bitmapCache->persistent);
+
+	free(bitmapCache);
+}
+
+static void free_bitmap_data(BITMAP_DATA* data, size_t count)
+{
+	if (!data)
+		return;
+
+	for (size_t x = 0; x < count; x++)
+		free(data[x].bitmapDataStream);
+
+	free(data);
+}
+
+static BITMAP_DATA* copy_bitmap_data(const BITMAP_DATA* data, size_t count)
+{
+	BITMAP_DATA* dst = (BITMAP_DATA*)calloc(count, sizeof(BITMAP_DATA));
+
+	if (!dst)
+		goto fail;
+
+	for (size_t x = 0; x < count; x++)
+	{
+		dst[x] = data[x];
+
+		if (data[x].bitmapLength > 0)
+		{
+			dst[x].bitmapDataStream = malloc(data[x].bitmapLength);
+
+			if (!dst[x].bitmapDataStream)
+				goto fail;
+
+			memcpy(dst[x].bitmapDataStream, data[x].bitmapDataStream, data[x].bitmapLength);
+		}
+	}
+
+	return dst;
+fail:
+	free_bitmap_data(dst, count);
+	return NULL;
+}
+
+void free_bitmap_update(rdpContext* context, BITMAP_UPDATE* pointer)
+{
+	if (!pointer)
+		return;
+
+	free_bitmap_data(pointer->rectangles, pointer->number);
+	free(pointer);
+}
+
+BITMAP_UPDATE* copy_bitmap_update(rdpContext* context, const BITMAP_UPDATE* pointer)
+{
+	BITMAP_UPDATE* dst = calloc(1, sizeof(BITMAP_UPDATE));
+
+	if (!dst || !pointer)
+		goto fail;
+
+	*dst = *pointer;
+	dst->rectangles = copy_bitmap_data(pointer->rectangles, pointer->number);
+
+	if (!dst->rectangles)
+		goto fail;
+
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_bitmap_update(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+CACHE_BITMAP_ORDER* copy_cache_bitmap_order(rdpContext* context, const CACHE_BITMAP_ORDER* order)
+{
+	CACHE_BITMAP_ORDER* dst = calloc(1, sizeof(CACHE_BITMAP_ORDER));
+
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+
+	if (order->bitmapLength > 0)
+	{
+		dst->bitmapDataStream = malloc(order->bitmapLength);
+
+		if (!dst->bitmapDataStream)
+			goto fail;
+
+		memcpy(dst->bitmapDataStream, order->bitmapDataStream, order->bitmapLength);
+	}
+
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_cache_bitmap_order(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void free_cache_bitmap_order(rdpContext* context, CACHE_BITMAP_ORDER* order)
+{
+	if (order)
+		free(order->bitmapDataStream);
+
+	free(order);
+}
+
+CACHE_BITMAP_V2_ORDER* copy_cache_bitmap_v2_order(rdpContext* context,
+                                                  const CACHE_BITMAP_V2_ORDER* order)
+{
+	CACHE_BITMAP_V2_ORDER* dst = calloc(1, sizeof(CACHE_BITMAP_V2_ORDER));
+
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+
+	if (order->bitmapLength > 0)
+	{
+		dst->bitmapDataStream = malloc(order->bitmapLength);
+
+		if (!dst->bitmapDataStream)
+			goto fail;
+
+		memcpy(dst->bitmapDataStream, order->bitmapDataStream, order->bitmapLength);
+	}
+
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_cache_bitmap_v2_order(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void free_cache_bitmap_v2_order(rdpContext* context, CACHE_BITMAP_V2_ORDER* order)
+{
+	if (order)
+		free(order->bitmapDataStream);
+
+	free(order);
+}
+
+CACHE_BITMAP_V3_ORDER* copy_cache_bitmap_v3_order(rdpContext* context,
+                                                  const CACHE_BITMAP_V3_ORDER* order)
+{
+	CACHE_BITMAP_V3_ORDER* dst = calloc(1, sizeof(CACHE_BITMAP_V3_ORDER));
+
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+
+	if (order->bitmapData.length > 0)
+	{
+		dst->bitmapData.data = malloc(order->bitmapData.length);
+
+		if (!dst->bitmapData.data)
+			goto fail;
+
+		memcpy(dst->bitmapData.data, order->bitmapData.data, order->bitmapData.length);
+	}
+
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_cache_bitmap_v3_order(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void free_cache_bitmap_v3_order(rdpContext* context, CACHE_BITMAP_V3_ORDER* order)
+{
+	if (order)
+		free(order->bitmapData.data);
+
+	free(order);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/brush.h

@@ -0,0 +1,57 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Brush Cache
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_BRUSH_CACHE_H
+#define FREERDP_LIB_BRUSH_CACHE_H
+
+#include <freerdp/api.h>
+#include <freerdp/types.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/update.h>
+
+#include <winpr/stream.h>
+
+typedef struct rdp_brush_cache rdpBrushCache;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL void* brush_cache_get(rdpBrushCache* brush, UINT32 index, UINT32* bpp);
+	FREERDP_LOCAL void brush_cache_put(rdpBrushCache* brush, UINT32 index, void* entry, UINT32 bpp);
+
+	FREERDP_LOCAL void brush_cache_register_callbacks(rdpUpdate* update);
+
+	FREERDP_LOCAL void brush_cache_free(rdpBrushCache* brush);
+
+	WINPR_ATTR_MALLOC(brush_cache_free, 1)
+	FREERDP_LOCAL rdpBrushCache* brush_cache_new(rdpContext* context);
+
+	FREERDP_LOCAL void free_cache_brush_order(rdpContext* context, CACHE_BRUSH_ORDER* order);
+
+	WINPR_ATTR_MALLOC(free_cache_brush_order, 1)
+	FREERDP_LOCAL CACHE_BRUSH_ORDER* copy_cache_brush_order(rdpContext* context,
+	                                                        const CACHE_BRUSH_ORDER* order);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_BRUSH_CACHE_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/cache.c

@@ -0,0 +1,152 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Caches
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+
+#include <winpr/stream.h>
+
+#include "cache.h"
+
+rdpCache* cache_new(rdpContext* context)
+{
+	rdpCache* cache = NULL;
+
+	WINPR_ASSERT(context);
+
+	cache = (rdpCache*)calloc(1, sizeof(rdpCache));
+
+	if (!cache)
+		return NULL;
+
+	cache->glyph = glyph_cache_new(context);
+
+	if (!cache->glyph)
+		goto error;
+
+	cache->brush = brush_cache_new(context);
+
+	if (!cache->brush)
+		goto error;
+
+	cache->pointer = pointer_cache_new(context);
+
+	if (!cache->pointer)
+		goto error;
+
+	cache->bitmap = bitmap_cache_new(context);
+
+	if (!cache->bitmap)
+		goto error;
+
+	cache->offscreen = offscreen_cache_new(context);
+
+	if (!cache->offscreen)
+		goto error;
+
+	cache->palette = palette_cache_new(context);
+
+	if (!cache->palette)
+		goto error;
+
+	cache->nine_grid = nine_grid_cache_new(context);
+
+	if (!cache->nine_grid)
+		goto error;
+
+	return cache;
+error:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	cache_free(cache);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void cache_free(rdpCache* cache)
+{
+	if (cache != NULL)
+	{
+		glyph_cache_free(cache->glyph);
+		brush_cache_free(cache->brush);
+		pointer_cache_free(cache->pointer);
+		bitmap_cache_free(cache->bitmap);
+		offscreen_cache_free(cache->offscreen);
+		palette_cache_free(cache->palette);
+		nine_grid_cache_free(cache->nine_grid);
+		free(cache);
+	}
+}
+
+CACHE_COLOR_TABLE_ORDER* copy_cache_color_table_order(rdpContext* context,
+                                                      const CACHE_COLOR_TABLE_ORDER* order)
+{
+	CACHE_COLOR_TABLE_ORDER* dst = calloc(1, sizeof(CACHE_COLOR_TABLE_ORDER));
+
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_cache_color_table_order(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void free_cache_color_table_order(rdpContext* context, CACHE_COLOR_TABLE_ORDER* order)
+{
+	free(order);
+}
+
+SURFACE_BITS_COMMAND* copy_surface_bits_command(rdpContext* context,
+                                                const SURFACE_BITS_COMMAND* order)
+{
+	SURFACE_BITS_COMMAND* dst = calloc(1, sizeof(SURFACE_BITS_COMMAND));
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+
+	dst->bmp.bitmapData = (BYTE*)malloc(order->bmp.bitmapDataLength);
+
+	if (!dst->bmp.bitmapData)
+		goto fail;
+
+	CopyMemory(dst->bmp.bitmapData, order->bmp.bitmapData, order->bmp.bitmapDataLength);
+
+	return dst;
+
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_surface_bits_command(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void free_surface_bits_command(rdpContext* context, SURFACE_BITS_COMMAND* order)
+{
+	if (order)
+		free(order->bmp.bitmapData);
+	free(order);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/cache.h

@@ -0,0 +1,73 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2018 Armin Novak <[email protected]>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CACHE_CACHE_H
+#define FREERDP_LIB_CACHE_CACHE_H
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/pointer.h>
+
+#include "glyph.h"
+#include "brush.h"
+#include "pointer.h"
+#include "bitmap.h"
+#include "nine_grid.h"
+#include "offscreen.h"
+#include "palette.h"
+
+struct rdp_cache
+{
+	rdpGlyphCache* glyph;         /* 0 */
+	rdpBrushCache* brush;         /* 1 */
+	rdpPointerCache* pointer;     /* 2 */
+	rdpBitmapCache* bitmap;       /* 3 */
+	rdpOffscreenCache* offscreen; /* 4 */
+	rdpPaletteCache* palette;     /* 5 */
+	rdpNineGridCache* nine_grid;  /* 6 */
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL void cache_free(rdpCache* cache);
+
+	WINPR_ATTR_MALLOC(cache_free, 1)
+	FREERDP_LOCAL rdpCache* cache_new(rdpContext* context);
+
+	FREERDP_LOCAL void free_cache_color_table_order(rdpContext* context,
+	                                                CACHE_COLOR_TABLE_ORDER* order);
+
+	WINPR_ATTR_MALLOC(free_cache_color_table_order, 2)
+	FREERDP_LOCAL CACHE_COLOR_TABLE_ORDER*
+	copy_cache_color_table_order(rdpContext* context, const CACHE_COLOR_TABLE_ORDER* order);
+
+	FREERDP_LOCAL void free_surface_bits_command(rdpContext* context, SURFACE_BITS_COMMAND* order);
+
+	WINPR_ATTR_MALLOC(free_surface_bits_command, 2)
+	FREERDP_LOCAL SURFACE_BITS_COMMAND*
+	copy_surface_bits_command(rdpContext* context, const SURFACE_BITS_COMMAND* order);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CACHE_CACHE_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/persistent.c

@@ -0,0 +1,376 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Persistent Bitmap Cache
+ *
+ * Copyright 2016 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/stream.h>
+#include <winpr/assert.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+
+#include <freerdp/cache/persistent.h>
+
+struct rdp_persistent_cache
+{
+	FILE* fp;
+	BOOL write;
+	int version;
+	int count;
+	char* filename;
+	BYTE* bmpData;
+	UINT32 bmpSize;
+};
+
+static const char sig_str[] = "RDP8bmp";
+
+int persistent_cache_get_version(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+	return persistent->version;
+}
+
+int persistent_cache_get_count(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+	return persistent->count;
+}
+
+static int persistent_cache_read_entry_v2(rdpPersistentCache* persistent,
+                                          PERSISTENT_CACHE_ENTRY* entry)
+{
+	PERSISTENT_CACHE_ENTRY_V2 entry2 = { 0 };
+
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+
+	if (fread((void*)&entry2, sizeof(entry2), 1, persistent->fp) != 1)
+		return -1;
+
+	entry->key64 = entry2.key64;
+	entry->width = entry2.width;
+	entry->height = entry2.height;
+	entry->size = entry2.width * entry2.height * 4;
+	entry->flags = entry2.flags;
+
+	entry->data = persistent->bmpData;
+
+	if (fread((void*)entry->data, 0x4000, 1, persistent->fp) != 1)
+		return -1;
+
+	return 1;
+}
+
+static int persistent_cache_write_entry_v2(rdpPersistentCache* persistent,
+                                           const PERSISTENT_CACHE_ENTRY* entry)
+{
+	PERSISTENT_CACHE_ENTRY_V2 entry2 = { 0 };
+
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+	entry2.key64 = entry->key64;
+	entry2.width = entry->width;
+	entry2.height = entry->height;
+	entry2.size = entry->size;
+	entry2.flags = entry->flags;
+
+	if (!entry2.flags)
+		entry2.flags = 0x00000011;
+
+	if (fwrite(&entry2, sizeof(entry2), 1, persistent->fp) != 1)
+		return -1;
+
+	if (fwrite(entry->data, entry->size, 1, persistent->fp) != 1)
+		return -1;
+
+	if (0x4000 > entry->size)
+	{
+		const size_t padding = 0x4000 - entry->size;
+
+		if (fwrite(persistent->bmpData, padding, 1, persistent->fp) != 1)
+			return -1;
+	}
+
+	persistent->count++;
+
+	return 1;
+}
+
+static int persistent_cache_read_v2(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+	while (1)
+	{
+		PERSISTENT_CACHE_ENTRY_V2 entry = { 0 };
+
+		if (fread((void*)&entry, sizeof(entry), 1, persistent->fp) != 1)
+			break;
+
+		if (fseek(persistent->fp, 0x4000, SEEK_CUR) != 0)
+			break;
+
+		persistent->count++;
+	}
+
+	return 1;
+}
+
+static int persistent_cache_read_entry_v3(rdpPersistentCache* persistent,
+                                          PERSISTENT_CACHE_ENTRY* entry)
+{
+	PERSISTENT_CACHE_ENTRY_V3 entry3 = { 0 };
+
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+
+	if (fread(&entry3, sizeof(entry3), 1, persistent->fp) != 1)
+		return -1;
+
+	entry->key64 = entry3.key64;
+	entry->width = entry3.width;
+	entry->height = entry3.height;
+	const UINT64 size = 4ull * entry3.width * entry3.height;
+	if (size > UINT32_MAX)
+		return -1;
+	entry->size = (UINT32)size;
+	entry->flags = 0;
+
+	if (entry->size > persistent->bmpSize)
+	{
+		persistent->bmpSize = entry->size;
+		BYTE* bmpData = (BYTE*)winpr_aligned_recalloc(persistent->bmpData, persistent->bmpSize,
+		                                              sizeof(BYTE), 32);
+
+		if (!bmpData)
+			return -1;
+
+		persistent->bmpData = bmpData;
+	}
+
+	entry->data = persistent->bmpData;
+
+	if (fread((void*)entry->data, entry->size, 1, persistent->fp) != 1)
+		return -1;
+
+	return 1;
+}
+
+static int persistent_cache_write_entry_v3(rdpPersistentCache* persistent,
+                                           const PERSISTENT_CACHE_ENTRY* entry)
+{
+	PERSISTENT_CACHE_ENTRY_V3 entry3 = { 0 };
+
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+
+	entry3.key64 = entry->key64;
+	entry3.width = entry->width;
+	entry3.height = entry->height;
+
+	if (fwrite((void*)&entry3, sizeof(entry3), 1, persistent->fp) != 1)
+		return -1;
+
+	if (fwrite((void*)entry->data, entry->size, 1, persistent->fp) != 1)
+		return -1;
+
+	persistent->count++;
+
+	return 1;
+}
+
+static int persistent_cache_read_v3(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+	while (1)
+	{
+		PERSISTENT_CACHE_ENTRY_V3 entry = { 0 };
+
+		if (fread((void*)&entry, sizeof(entry), 1, persistent->fp) != 1)
+			break;
+
+		if (_fseeki64(persistent->fp, (4LL * entry.width * entry.height), SEEK_CUR) != 0)
+			break;
+
+		persistent->count++;
+	}
+
+	return 1;
+}
+
+int persistent_cache_read_entry(rdpPersistentCache* persistent, PERSISTENT_CACHE_ENTRY* entry)
+{
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+
+	if (persistent->version == 3)
+		return persistent_cache_read_entry_v3(persistent, entry);
+	else if (persistent->version == 2)
+		return persistent_cache_read_entry_v2(persistent, entry);
+
+	return -1;
+}
+
+int persistent_cache_write_entry(rdpPersistentCache* persistent,
+                                 const PERSISTENT_CACHE_ENTRY* entry)
+{
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(entry);
+
+	if (persistent->version == 3)
+		return persistent_cache_write_entry_v3(persistent, entry);
+	else if (persistent->version == 2)
+		return persistent_cache_write_entry_v2(persistent, entry);
+
+	return -1;
+}
+
+static int persistent_cache_open_read(rdpPersistentCache* persistent)
+{
+	BYTE sig[8] = { 0 };
+	int status = 1;
+	long offset = 0;
+
+	WINPR_ASSERT(persistent);
+	persistent->fp = winpr_fopen(persistent->filename, "rb");
+
+	if (!persistent->fp)
+		return -1;
+
+	if (fread(sig, 8, 1, persistent->fp) != 1)
+		return -1;
+
+	if (memcmp(sig, sig_str, sizeof(sig_str)) == 0)
+		persistent->version = 3;
+	else
+		persistent->version = 2;
+
+	(void)fseek(persistent->fp, 0, SEEK_SET);
+
+	if (persistent->version == 3)
+	{
+		PERSISTENT_CACHE_HEADER_V3 header;
+
+		if (fread(&header, sizeof(header), 1, persistent->fp) != 1)
+			return -1;
+
+		status = persistent_cache_read_v3(persistent);
+		offset = sizeof(header);
+	}
+	else
+	{
+		status = persistent_cache_read_v2(persistent);
+		offset = 0;
+	}
+
+	(void)fseek(persistent->fp, offset, SEEK_SET);
+
+	return status;
+}
+
+static int persistent_cache_open_write(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+
+	persistent->fp = winpr_fopen(persistent->filename, "w+b");
+
+	if (!persistent->fp)
+		return -1;
+
+	if (persistent->version == 3)
+	{
+		PERSISTENT_CACHE_HEADER_V3 header = { 0 };
+		memcpy(header.sig, sig_str, MIN(sizeof(header.sig), sizeof(sig_str)));
+		header.flags = 0x00000006;
+
+		if (fwrite(&header, sizeof(header), 1, persistent->fp) != 1)
+			return -1;
+	}
+
+	ZeroMemory(persistent->bmpData, persistent->bmpSize);
+
+	return 1;
+}
+
+int persistent_cache_open(rdpPersistentCache* persistent, const char* filename, BOOL write,
+                          UINT32 version)
+{
+	WINPR_ASSERT(persistent);
+	WINPR_ASSERT(filename);
+	persistent->write = write;
+
+	persistent->filename = _strdup(filename);
+
+	if (!persistent->filename)
+		return -1;
+
+	if (persistent->write)
+	{
+		WINPR_ASSERT(version <= INT32_MAX);
+		persistent->version = (int)version;
+		return persistent_cache_open_write(persistent);
+	}
+
+	return persistent_cache_open_read(persistent);
+}
+
+int persistent_cache_close(rdpPersistentCache* persistent)
+{
+	WINPR_ASSERT(persistent);
+	if (persistent->fp)
+	{
+		(void)fclose(persistent->fp);
+		persistent->fp = NULL;
+	}
+
+	return 1;
+}
+
+rdpPersistentCache* persistent_cache_new(void)
+{
+	rdpPersistentCache* persistent = calloc(1, sizeof(rdpPersistentCache));
+
+	if (!persistent)
+		return NULL;
+
+	persistent->bmpSize = 0x4000;
+	persistent->bmpData = calloc(1, persistent->bmpSize);
+
+	if (!persistent->bmpData)
+	{
+		free(persistent);
+		return NULL;
+	}
+
+	return persistent;
+}
+
+void persistent_cache_free(rdpPersistentCache* persistent)
+{
+	if (!persistent)
+		return;
+
+	persistent_cache_close(persistent);
+
+	free(persistent->filename);
+
+	winpr_aligned_free(persistent->bmpData);
+
+	free(persistent);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/common/assistance.c

@@ -0,0 +1,1503 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Remote Assistance
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+
+#include <winpr/wtypes.h>
+#include <winpr/collections.h>
+#include <winpr/string.h>
+#include <winpr/crt.h>
+#include <winpr/crypto.h>
+#include <winpr/print.h>
+#include <winpr/windows.h>
+#include <winpr/ssl.h>
+#include <winpr/file.h>
+
+#include <freerdp/log.h>
+#include <freerdp/client/file.h>
+#include <freerdp/client/cmdline.h>
+
+#include <freerdp/assistance.h>
+
+#include "../core/settings.h"
+
+#define TAG FREERDP_TAG("common")
+
+struct rdp_assistance_file
+{
+	UINT32 Type;
+
+	char* Username;
+	char* LHTicket;
+	char* RCTicket;
+	char* PassStub;
+	UINT32 DtStart;
+	UINT32 DtLength;
+	BOOL LowSpeed;
+	BOOL RCTicketEncrypted;
+
+	char* ConnectionString1;
+	char* ConnectionString2;
+
+	BYTE* EncryptedPassStub;
+	size_t EncryptedPassStubLength;
+
+	BYTE* EncryptedLHTicket;
+	size_t EncryptedLHTicketLength;
+
+	wArrayList* MachineAddresses;
+	wArrayList* MachinePorts;
+	wArrayList* MachineUris;
+
+	char* RASessionId;
+	char* RASpecificParams;
+	char* RASpecificParams2;
+
+	char* filename;
+	char* password;
+};
+
+static const char* strrstr(const char* haystack, size_t len, const char* needle)
+{
+	if (*needle == '\0')
+		return haystack;
+
+	char* result = NULL;
+	for (;;)
+	{
+		char* p = strstr(haystack, needle);
+		if (p == NULL)
+			break;
+		if (p > haystack + len)
+			return NULL;
+
+		result = p;
+		haystack = p + 1;
+	}
+
+	return result;
+}
+
+static BOOL update_option(char** opt, const char* val, size_t len)
+{
+	WINPR_ASSERT(opt);
+	free(*opt);
+	*opt = NULL;
+
+	if (!val && (len != 0))
+		return FALSE;
+	else if (!val && (len == 0))
+		return TRUE;
+	*opt = strndup(val, len);
+	return *opt != NULL;
+}
+
+static BOOL update_name(rdpAssistanceFile* file, const char* name)
+{
+	WINPR_ASSERT(file);
+
+	if (!name)
+	{
+		WLog_ERR(TAG, "ASSISTANCE file %s invalid name", name);
+		return FALSE;
+	}
+
+	free(file->filename);
+	file->filename = _strdup(name);
+	return file->filename != NULL;
+}
+
+static BOOL update_password(rdpAssistanceFile* file, const char* password)
+{
+	WINPR_ASSERT(file);
+	free(file->password);
+	file->password = NULL;
+	if (!password)
+		return TRUE;
+	file->password = _strdup(password);
+	return file->password != NULL;
+}
+
+static BOOL update_connectionstring2_nocopy(rdpAssistanceFile* file, char* str)
+{
+	WINPR_ASSERT(file);
+	free(file->ConnectionString2);
+	file->ConnectionString2 = NULL;
+	if (!str)
+		return TRUE;
+	file->ConnectionString2 = str;
+	return file->ConnectionString2 != NULL;
+}
+
+static BOOL update_connectionstring2(rdpAssistanceFile* file, const char* str, size_t len)
+{
+	char* strc = NULL;
+	if (!str && (len != 0))
+		return FALSE;
+
+	if (str && (len > 0))
+	{
+		strc = strndup(str, len);
+		if (!strc)
+			return FALSE;
+	}
+	return update_connectionstring2_nocopy(file, strc);
+}
+
+static BOOL update_connectionstring2_wchar(rdpAssistanceFile* file, const WCHAR* str, size_t len)
+{
+	char* strc = NULL;
+
+	if (!str && (len != 0))
+		return FALSE;
+
+	if (str && (len > 0))
+	{
+		strc = ConvertWCharNToUtf8Alloc(str, len, NULL);
+		if (!strc)
+			return FALSE;
+	}
+	return update_connectionstring2_nocopy(file, strc);
+}
+
+/**
+ * Password encryption in establishing a remote assistance session of type 1:
+ * http://blogs.msdn.com/b/openspecification/archive/2011/10/31/password-encryption-in-establishing-a-remote-assistance-session-of-type-1.aspx
+ *
+ * Creation of PassStub for the Remote Assistance Ticket:
+ * http://social.msdn.microsoft.com/Forums/en-US/6316c3f4-ea09-4343-a4a1-9cca46d70d28/creation-of-passstub-for-the-remote-assistance-ticket?forum=os_windowsprotocols
+ */
+
+/**
+ * CryptDeriveKey Function:
+ * http://msdn.microsoft.com/en-us/library/windows/desktop/aa379916/
+ *
+ * Let n be the required derived key length, in bytes.
+ * The derived key is the first n bytes of the hash value after the hash computation
+ * has been completed by CryptDeriveKey. If the hash is not a member of the SHA-2
+ * family and the required key is for either 3DES or AES, the key is derived as follows:
+ *
+ * Form a 64-byte buffer by repeating the constant 0x36 64 times.
+ * Let k be the length of the hash value that is represented by the input parameter hBaseData.
+ * Set the first k bytes of the buffer to the result of an XOR operation of the first k bytes
+ * of the buffer with the hash value that is represented by the input parameter hBaseData.
+ *
+ * Form a 64-byte buffer by repeating the constant 0x5C 64 times.
+ * Set the first k bytes of the buffer to the result of an XOR operation of the first k bytes
+ * of the buffer with the hash value that is represented by the input parameter hBaseData.
+ *
+ * Hash the result of step 1 by using the same hash algorithm as that used to compute the hash
+ * value that is represented by the hBaseData parameter.
+ *
+ * Hash the result of step 2 by using the same hash algorithm as that used to compute the hash
+ * value that is represented by the hBaseData parameter.
+ *
+ * Concatenate the result of step 3 with the result of step 4.
+ * Use the first n bytes of the result of step 5 as the derived key.
+ */
+
+static BOOL freerdp_assistance_crypt_derive_key_sha1(const BYTE* hash, size_t hashLength, BYTE* key,
+                                                     size_t keyLength)
+{
+	BOOL rc = FALSE;
+	BYTE pad1[64] = { 0 };
+	BYTE pad2[64] = { 0 };
+
+	if (hashLength == 0)
+		return FALSE;
+
+	memset(pad1, 0x36, sizeof(pad1));
+	memset(pad2, 0x5C, sizeof(pad2));
+
+	for (size_t i = 0; i < hashLength; i++)
+	{
+		pad1[i] ^= hash[i];
+		pad2[i] ^= hash[i];
+	}
+
+	BYTE* buffer = (BYTE*)calloc(hashLength, 2);
+
+	if (!buffer)
+		goto fail;
+
+	if (!winpr_Digest(WINPR_MD_SHA1, pad1, 64, buffer, hashLength))
+		goto fail;
+
+	if (!winpr_Digest(WINPR_MD_SHA1, pad2, 64, &buffer[hashLength], hashLength))
+		goto fail;
+
+	CopyMemory(key, buffer, keyLength);
+	rc = TRUE;
+fail:
+	free(buffer);
+	return rc;
+}
+
+static BOOL append_address_to_list(wArrayList* MachineAddresses, const char* str, size_t len)
+{
+	char* copy = NULL;
+	if (len > 0)
+		copy = strndup(str, len);
+	if (!copy)
+		return FALSE;
+
+	const BOOL rc = ArrayList_Append(MachineAddresses, copy);
+	if (!rc)
+		free(copy);
+	// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append takes ownership of copy
+	return rc;
+}
+
+static BOOL append_address(rdpAssistanceFile* file, const char* host, const char* port)
+{
+	WINPR_ASSERT(file);
+
+	errno = 0;
+	unsigned long p = strtoul(port, NULL, 0);
+
+	if ((errno != 0) || (p == 0) || (p > UINT16_MAX))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 invalid port value %s",
+		         port);
+		return FALSE;
+	}
+
+	if (!append_address_to_list(file->MachineAddresses, host, host ? strlen(host) : 0))
+		return FALSE;
+	return ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p);
+}
+
+static BOOL freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
+{
+	WINPR_ASSERT(file);
+
+	WLog_DBG(TAG, "freerdp_assistance_parse_address_list list=%s", list);
+
+	BOOL rc = FALSE;
+
+	if (!list)
+		return FALSE;
+
+	char* strp = list;
+	char* s = ";";
+
+	// get the first token
+	char* saveptr = NULL;
+	char* token = strtok_s(strp, s, &saveptr);
+
+	// walk through other tokens
+	while (token != NULL)
+	{
+		char* port = strchr(token, ':');
+		if (!port)
+			goto out;
+		*port = '\0';
+		port++;
+
+		if (!append_address(file, token, port))
+			goto out;
+
+		token = strtok_s(NULL, s, &saveptr);
+	}
+	rc = TRUE;
+out:
+	return rc;
+}
+
+static BOOL freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
+{
+	char* tokens[8] = { 0 };
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(file);
+
+	if (!file->RCTicket)
+		return FALSE;
+
+	/**
+	 * <ProtocolVersion>,<protocolType>,<machineAddressList>,<assistantAccountPwd>,
+	 * <RASessionID>,<RASessionName>,<RASessionPwd>,<protocolSpecificParms>
+	 */
+	char* str = _strdup(file->RCTicket);
+
+	if (!str)
+		goto error;
+
+	const size_t length = strlen(str);
+
+	int count = 1;
+	for (size_t i = 0; i < length; i++)
+	{
+		if (str[i] == ',')
+			count++;
+	}
+
+	if (count != 8)
+		goto error;
+
+	count = 0;
+	tokens[count++] = str;
+
+	for (size_t i = 0; i < length; i++)
+	{
+		if (str[i] == ',')
+		{
+			str[i] = '\0';
+			tokens[count++] = &str[i + 1];
+		}
+	}
+
+	if (strcmp(tokens[0], "65538") != 0)
+		goto error;
+
+	if (strcmp(tokens[1], "1") != 0)
+		goto error;
+
+	if (strcmp(tokens[3], "*") != 0)
+		goto error;
+
+	if (strcmp(tokens[5], "*") != 0)
+		goto error;
+
+	if (strcmp(tokens[6], "*") != 0)
+		goto error;
+
+	file->RASessionId = _strdup(tokens[4]);
+
+	if (!file->RASessionId)
+		goto error;
+
+	file->RASpecificParams = _strdup(tokens[7]);
+
+	if (!file->RASpecificParams)
+		goto error;
+
+	if (!freerdp_assistance_parse_address_list(file, tokens[2]))
+		goto error;
+
+	rc = TRUE;
+error:
+	free(str);
+	return rc;
+}
+
+/**
+ * Decrypted Connection String 2:
+ *
+ * <E>
+ * <A KH="BNRjdu97DyczQSRuMRrDWoue+HA="
+ * ID="+ULZ6ifjoCa6cGPMLQiGHRPwkg6VyJqGwxMnO6GcelwUh9a6/FBq3It5ADSndmLL"/> <C> <T ID="1" SID="0"> <L
+ * P="49228" N="fe80::1032:53d9:5a01:909b%3"/> <L P="49229" N="fe80::3d8f:9b2d:6b4e:6aa%6"/> <L
+ * P="49230" N="192.168.1.200"/> <L P="49231" N="169.254.6.170"/>
+ * </T>
+ * </C>
+ * </E>
+ */
+
+static BOOL freerdp_assistance_parse_attr(const char** opt, size_t* plength, const char* key,
+                                          const char* tag)
+{
+	WINPR_ASSERT(opt);
+	WINPR_ASSERT(plength);
+	WINPR_ASSERT(key);
+
+	*opt = NULL;
+	*plength = 0;
+	if (!tag)
+		return FALSE;
+
+	char bkey[128] = { 0 };
+	const int rc = _snprintf(bkey, sizeof(bkey), "%s=\"", key);
+	WINPR_ASSERT(rc > 0);
+	WINPR_ASSERT((size_t)rc < sizeof(bkey));
+	if ((rc <= 0) || ((size_t)rc >= sizeof(bkey)))
+		return FALSE;
+
+	char* p = strstr(tag, bkey);
+	if (!p)
+		return TRUE;
+
+	p += strlen(bkey);
+	char* q = strchr(p, '"');
+
+	if (!q)
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 invalid field '%s=%s'",
+		         key, p);
+		return FALSE;
+	}
+
+	if (p > q)
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: ConnectionString2 invalid field "
+		         "order for '%s'",
+		         key);
+		return FALSE;
+	}
+	const size_t length = WINPR_ASSERTING_INT_CAST(size_t, q - p);
+	*opt = p;
+	*plength = length;
+
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_attr_str(char** opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+	return update_option(opt, copt, size);
+}
+
+static BOOL freerdp_assistance_parse_attr_bool(BOOL* opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+
+	WINPR_ASSERT(opt);
+	*opt = FALSE;
+
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+	if (size != 1)
+		return TRUE;
+
+	*opt = (copt[0] == '1');
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_attr_uint32(UINT32* opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+
+	WINPR_ASSERT(opt);
+	*opt = 0;
+
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+
+	char buffer[64] = { 0 };
+	if ((!copt && (size > 0)) || (size >= sizeof(buffer)))
+	{
+		WLog_WARN(TAG, "Invalid UINT32 string '%s' [%" PRIuz "]", copt, size);
+		return FALSE;
+	}
+
+	if (size > 0)
+		strncpy(buffer, copt, size);
+
+	errno = 0;
+	unsigned long val = strtoul(buffer, NULL, 0);
+
+	if ((errno != 0) || (val > UINT32_MAX))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Invalid value %s", buffer);
+		return FALSE;
+	}
+
+	*opt = (UINT32)val;
+
+	return TRUE;
+}
+
+static char* freerdp_assistance_contains_element(char* input, size_t ilen, const char* key,
+                                                 size_t* plen, char** pdata, size_t* pdlen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(plen);
+
+	char bkey[128] = { 0 };
+	const int rc = _snprintf(bkey, sizeof(bkey), "<%s", key);
+	WINPR_ASSERT(rc > 0);
+	WINPR_ASSERT((size_t)rc < sizeof(bkey));
+	if ((rc < 0) || ((size_t)rc >= sizeof(bkey)))
+		return NULL;
+
+	char* tag = strstr(input, bkey);
+	if (!tag || (tag > input + ilen))
+		return NULL;
+
+	char* data = tag + strnlen(bkey, sizeof(bkey));
+
+	/* Ensure there is a valid delimiter following our token */
+	switch (data[0])
+	{
+		case '>':
+		case '/':
+		case ' ':
+		case '\t':
+			break;
+		default:
+			WLog_ERR(TAG,
+			         "Failed to parse ASSISTANCE file: ConnectionString2 missing delimiter after "
+			         "field %s",
+			         bkey);
+			return NULL;
+	}
+
+	char* start = strstr(tag, ">");
+
+	if (!start || (start > input + ilen))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 missing field %s", bkey);
+		return NULL;
+	}
+
+	const char* end = start;
+	const char* dend = start - 1;
+	if (*dend != '/')
+	{
+		char ekey[128] = { 0 };
+		const int erc = _snprintf(ekey, sizeof(ekey), "</%s>", key);
+		WINPR_ASSERT(erc > 0);
+		WINPR_ASSERT((size_t)erc < sizeof(ekey));
+		if ((erc <= 0) || ((size_t)erc >= sizeof(ekey)))
+			return NULL;
+		const size_t offset = WINPR_ASSERTING_INT_CAST(size_t, start - tag);
+		dend = end = strrstr(start, ilen - offset, ekey);
+		if (end)
+			end += strnlen(ekey, sizeof(ekey));
+	}
+
+	if (!end)
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: ConnectionString2 missing end tag for field %s",
+		         key);
+		return NULL;
+	}
+	if (plen)
+		*plen = WINPR_ASSERTING_INT_CAST(size_t, end - tag);
+
+	if (pdata)
+		*pdata = data;
+	if (pdlen)
+		*pdlen = WINPR_ASSERTING_INT_CAST(size_t, dend - data);
+	return tag;
+}
+
+/**! \brief this function returns a XML element identified by \b key
+ * The input string will be manipulated, so that the element found is '\0' terminated.
+ *
+ * This function can not find multiple elements on the same level as the input string is changed!
+ */
+static BOOL freerdp_assistance_consume_input_and_get_element(char* input, const char* key,
+                                                             char** element, size_t* elen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(element);
+	WINPR_ASSERT(elen);
+
+	size_t len = 0;
+	size_t dlen = 0;
+	char* data = NULL;
+	char* tag = freerdp_assistance_contains_element(input, strlen(input), key, &len, &data, &dlen);
+	if (!tag)
+		return FALSE;
+
+	char* end = data + dlen;
+	*tag = '\0';
+	*end = '\0';
+	*element = data;
+	*elen = dlen + 1;
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_get_element(char* input, size_t ilen, const char* key,
+                                           char** element, size_t* elen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(element);
+	WINPR_ASSERT(elen);
+
+	size_t len = 0;
+	size_t dlen = 0;
+	char* data = NULL;
+	char* tag = freerdp_assistance_contains_element(input, ilen, key, &len, &data, &dlen);
+	if (!tag)
+		return FALSE;
+
+	if (tag + len > input + ilen)
+		return FALSE;
+
+	char* end = tag + len;
+	*element = data;
+	*elen = WINPR_ASSERTING_INT_CAST(size_t, end - data + 1);
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of(rdpAssistanceFile* file, char* data,
+                                                     size_t len, const char* key,
+                                                     BOOL (*fkt)(rdpAssistanceFile* file,
+                                                                 char* data, size_t len))
+{
+	char* val = NULL;
+	size_t vlen = 0;
+
+	while (freerdp_assistance_get_element(data, len, key, &val, &vlen))
+	{
+		data = val + vlen;
+		len = strnlen(data, len);
+		if (vlen > 0)
+		{
+			val[vlen - 1] = '\0';
+
+			if (!fkt(file, val, vlen))
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_l(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	UINT32 p = 0;
+	const char* n = NULL;
+	const char* u = NULL;
+	size_t nlen = 0;
+	size_t ulen = 0;
+	if (!freerdp_assistance_parse_attr_uint32(&p, "P", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr(&n, &nlen, "N", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr(&u, &ulen, "U", data))
+		return FALSE;
+
+	if (n && (nlen > 0))
+	{
+		if (!append_address_to_list(file->MachineAddresses, n, nlen))
+			return FALSE;
+		if (!ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p))
+			return FALSE;
+	}
+	if (u && (ulen > 0))
+	{
+		if (!append_address_to_list(file->MachineAddresses, u, ulen))
+			return FALSE;
+		if (!ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_t(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	UINT32 id = 0;
+	UINT32 sid = 0;
+	if (!freerdp_assistance_parse_attr_uint32(&id, "ID", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr_uint32(&sid, "SID", data))
+		return FALSE;
+	WLog_DBG(TAG, "transport id=%" PRIu32 ", sid=%" PRIu32, id, sid);
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "L",
+	                                                freerdp_assistance_parse_all_elements_of_l);
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_c(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "T",
+	                                                freerdp_assistance_parse_all_elements_of_t);
+}
+
+static BOOL freerdp_assistance_parse_find_elements_of_c(rdpAssistanceFile* file, char* data,
+                                                        size_t len)
+{
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "C",
+	                                                freerdp_assistance_parse_all_elements_of_c);
+}
+
+static BOOL freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(file);
+
+	if (!file->ConnectionString2)
+		return FALSE;
+
+	char* str = _strdup(file->ConnectionString2);
+	if (!str)
+		goto out_fail;
+
+	char* e = NULL;
+	size_t elen = 0;
+	if (!freerdp_assistance_consume_input_and_get_element(str, "E", &e, &elen))
+		goto out_fail;
+
+	if (!e || (elen == 0))
+		goto out_fail;
+
+	char* a = NULL;
+	size_t alen = 0;
+	if (!freerdp_assistance_get_element(e, elen, "A", &a, &alen))
+		goto out_fail;
+
+	if (!a || (alen == 0))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_find_elements_of_c(file, e, elen))
+		goto out_fail;
+
+	/* '\0' terminate the detected XML elements so
+	 * the parser can continue with terminated strings
+	 */
+	a[alen] = '\0';
+	if (!freerdp_assistance_parse_attr_str(&file->RASpecificParams, "KH", a))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_attr_str(&file->RASpecificParams2, "KH2", a))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_attr_str(&file->RASessionId, "ID", a))
+		goto out_fail;
+
+	rc = TRUE;
+out_fail:
+	free(str);
+	return rc;
+}
+
+char* freerdp_assistance_construct_expert_blob(const char* name, const char* pass)
+{
+	if (!name || !pass)
+		return NULL;
+
+	const size_t nameLength = strlen(name) + strlen("NAME=");
+	const size_t passLength = strlen(pass) + strlen("PASS=");
+	const size_t size = nameLength + passLength + 64;
+	char* ExpertBlob = (char*)calloc(1, size);
+
+	if (!ExpertBlob)
+		return NULL;
+
+	(void)sprintf_s(ExpertBlob, size, "%" PRIuz ";NAME=%s%" PRIuz ";PASS=%s", nameLength, name,
+	                passLength, pass);
+	return ExpertBlob;
+}
+
+char* freerdp_assistance_generate_pass_stub(DWORD flags)
+{
+	UINT32 nums[14];
+	char* passStub = NULL;
+	char set1[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789*_";
+	char set2[12] = "!@#$&^*()-+=";
+	char set3[10] = "0123456789";
+	char set4[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	char set5[26] = "abcdefghijklmnopqrstuvwxyz";
+	passStub = (char*)malloc(15);
+
+	if (!passStub)
+		return NULL;
+
+	/**
+	 * PassStub generation:
+	 *
+	 * Characters 0 and 5-13 are from the set A-Z a-z 0-9 * _
+	 * Character 1 is from the set !@#$&^*()-+=
+	 * Character 2 is from the set 0-9
+	 * Character 3 is from the set A-Z
+	 * Character 4 is from the set a-z
+	 *
+	 * Example: WB^6HsrIaFmEpi
+	 */
+	winpr_RAND(nums, sizeof(nums));
+	passStub[0] = set1[nums[0] % sizeof(set1)];   /* character 0 */
+	passStub[1] = set2[nums[1] % sizeof(set2)];   /* character 1 */
+	passStub[2] = set3[nums[2] % sizeof(set3)];   /* character 2 */
+	passStub[3] = set4[nums[3] % sizeof(set4)];   /* character 3 */
+	passStub[4] = set5[nums[4] % sizeof(set5)];   /* character 4 */
+	passStub[5] = set1[nums[5] % sizeof(set1)];   /* character 5 */
+	passStub[6] = set1[nums[6] % sizeof(set1)];   /* character 6 */
+	passStub[7] = set1[nums[7] % sizeof(set1)];   /* character 7 */
+	passStub[8] = set1[nums[8] % sizeof(set1)];   /* character 8 */
+	passStub[9] = set1[nums[9] % sizeof(set1)];   /* character 9 */
+	passStub[10] = set1[nums[10] % sizeof(set1)]; /* character 10 */
+	passStub[11] = set1[nums[11] % sizeof(set1)]; /* character 11 */
+	passStub[12] = set1[nums[12] % sizeof(set1)]; /* character 12 */
+	passStub[13] = set1[nums[13] % sizeof(set1)]; /* character 13 */
+	passStub[14] = '\0';
+	return passStub;
+}
+
+BYTE* freerdp_assistance_encrypt_pass_stub(const char* password, const char* passStub,
+                                           size_t* pEncryptedSize)
+{
+	BOOL rc = 0;
+	size_t cbPasswordW = 0;
+	size_t cbPassStubW = 0;
+	BYTE PasswordHash[WINPR_MD5_DIGEST_LENGTH] = { 0 };
+	WINPR_RC4_CTX* rc4Ctx = NULL;
+	BYTE* pbIn = NULL;
+	BYTE* pbOut = NULL;
+	BYTE* res = NULL;
+	WCHAR* PasswordW = ConvertUtf8ToWCharAlloc(password, &cbPasswordW);
+	WCHAR* PassStubW = ConvertUtf8ToWCharAlloc(passStub, &cbPassStubW);
+
+	cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
+	cbPassStubW = (cbPassStubW) * sizeof(WCHAR);
+	const size_t EncryptedSize = cbPassStubW + 4;
+
+	if (!PasswordW || !PassStubW)
+		goto fail;
+
+	if (!winpr_Digest(WINPR_MD_MD5, (BYTE*)PasswordW, cbPasswordW, (BYTE*)PasswordHash,
+	                  sizeof(PasswordHash)))
+		goto fail;
+
+	pbIn = (BYTE*)calloc(1, EncryptedSize);
+	pbOut = (BYTE*)calloc(1, EncryptedSize);
+
+	if (!pbIn || !pbOut)
+		goto fail;
+
+	WINPR_ASSERT(cbPasswordW <= UINT32_MAX);
+	winpr_Data_Write_UINT32(pbIn, (UINT32)cbPassStubW);
+	CopyMemory(&pbIn[4], PassStubW, cbPassStubW);
+	rc4Ctx = winpr_RC4_New(PasswordHash, sizeof(PasswordHash));
+
+	if (!rc4Ctx)
+	{
+		WLog_ERR(TAG, "winpr_Cipher_New failure");
+		goto fail;
+	}
+
+	rc = winpr_RC4_Update(rc4Ctx, EncryptedSize, pbIn, pbOut);
+
+	if (!rc)
+	{
+		WLog_ERR(TAG, "winpr_Cipher_Update failure");
+		goto fail;
+	}
+	res = pbOut;
+fail:
+	winpr_RC4_Free(rc4Ctx);
+	free(PasswordW);
+	free(PassStubW);
+	free(pbIn);
+	if (!res)
+		free(pbOut);
+	else
+		*pEncryptedSize = EncryptedSize;
+	return res;
+}
+
+static BOOL freerdp_assistance_decrypt2(rdpAssistanceFile* file)
+{
+	BOOL rc = FALSE;
+	int status = 0;
+	size_t cbPasswordW = 0;
+	size_t cchOutW = 0;
+	WINPR_CIPHER_CTX* aesDec = NULL;
+	WCHAR* PasswordW = NULL;
+	BYTE* pbIn = NULL;
+	BYTE* pbOut = NULL;
+	size_t cbOut = 0;
+	size_t cbIn = 0;
+	size_t cbFinal = 0;
+	BYTE DerivedKey[WINPR_AES_BLOCK_SIZE] = { 0 };
+	BYTE InitializationVector[WINPR_AES_BLOCK_SIZE] = { 0 };
+	BYTE PasswordHash[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+
+	WINPR_ASSERT(file);
+
+	if (!file->password)
+		return FALSE;
+
+	PasswordW = ConvertUtf8ToWCharAlloc(file->password, &cbPasswordW);
+	if (!PasswordW)
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Conversion from UCS2 to UTF8 failed");
+		return FALSE;
+	}
+
+	cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
+
+	if (!winpr_Digest(WINPR_MD_SHA1, (BYTE*)PasswordW, cbPasswordW, PasswordHash,
+	                  sizeof(PasswordHash)))
+		goto fail;
+
+	if (!freerdp_assistance_crypt_derive_key_sha1(PasswordHash, sizeof(PasswordHash), DerivedKey,
+	                                              sizeof(DerivedKey)))
+		goto fail;
+
+	aesDec =
+	    winpr_Cipher_NewEx(WINPR_CIPHER_AES_128_CBC, WINPR_DECRYPT, DerivedKey, sizeof(DerivedKey),
+	                       InitializationVector, sizeof(InitializationVector));
+
+	if (!aesDec)
+		goto fail;
+
+	cbOut = cbFinal = 0;
+	cbIn = file->EncryptedLHTicketLength;
+	pbIn = file->EncryptedLHTicket;
+	pbOut = (BYTE*)calloc(1, cbIn + WINPR_AES_BLOCK_SIZE + 2);
+
+	if (!pbOut)
+		goto fail;
+
+	if (!winpr_Cipher_Update(aesDec, pbIn, cbIn, pbOut, &cbOut))
+		goto fail;
+
+	if (!winpr_Cipher_Final(aesDec, pbOut + cbOut, &cbFinal))
+	{
+		WLog_ERR(TAG, "winpr_Cipher_Final failure");
+		goto fail;
+	}
+
+	cbOut += cbFinal;
+	cbFinal = 0;
+
+	union
+	{
+		const WCHAR* wc;
+		const BYTE* b;
+	} cnv;
+
+	cnv.b = pbOut;
+	cchOutW = cbOut / sizeof(WCHAR);
+
+	if (!update_connectionstring2_wchar(file, cnv.wc, cchOutW))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Conversion from UCS2 to UTF8 failed");
+		goto fail;
+	}
+
+	if (!freerdp_assistance_parse_connection_string2(file))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	winpr_Cipher_Free(aesDec);
+	free(PasswordW);
+	free(pbOut);
+	WLog_DBG(TAG, "freerdp_assistance_parse_connection_string2: %d", status);
+	return rc;
+}
+
+BYTE* freerdp_assistance_hex_string_to_bin(const void* raw, size_t* size)
+{
+	BYTE* buffer = NULL;
+	if (!raw || !size)
+		return NULL;
+	*size = 0;
+	const size_t length = strlen(raw);
+	buffer = calloc(length, sizeof(BYTE));
+	if (!buffer)
+		return NULL;
+	const size_t rc = winpr_HexStringToBinBuffer(raw, length, buffer, length);
+	if (rc == 0)
+	{
+		free(buffer);
+		return NULL;
+	}
+	*size = rc;
+	return buffer;
+}
+
+char* freerdp_assistance_bin_to_hex_string(const void* raw, size_t size)
+{
+	return winpr_BinToHexString(raw, size, FALSE);
+}
+
+static int freerdp_assistance_parse_uploadinfo(rdpAssistanceFile* file, char* uploadinfo,
+                                               size_t uploadinfosize)
+{
+	const char escalated[9] = "Escalated";
+	const size_t esclen = sizeof(escalated);
+	const char* typestr = NULL;
+	size_t typelen = 0;
+
+	if (!uploadinfo || (uploadinfosize == 0))
+		return -1;
+
+	if (strnlen(uploadinfo, uploadinfosize) == uploadinfosize)
+	{
+		WLog_WARN(TAG, "UPLOADINFOR string is not '\0' terminated");
+		return -1;
+	}
+
+	if (!freerdp_assistance_parse_attr(&typestr, &typelen, "TYPE", uploadinfo))
+		return -1;
+
+	if ((typelen != esclen) || (strncmp(typestr, escalated, esclen) != 0))
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: Missing or invalid UPLOADINFO TYPE '%s' [%" PRIuz
+		         "]",
+		         typestr, typelen);
+		return -1;
+	}
+
+	char* uploaddata = NULL;
+	size_t uploaddatasize = 0;
+	if (!freerdp_assistance_consume_input_and_get_element(uploadinfo, "UPLOADDATA", &uploaddata,
+	                                                      &uploaddatasize))
+		return -1;
+
+	/* Parse USERNAME */
+	if (!freerdp_assistance_parse_attr_str(&file->Username, "USERNAME", uploaddata))
+		return -1;
+
+	/* Parse LHTICKET */
+	if (!freerdp_assistance_parse_attr_str(&file->LHTicket, "LHTICKET", uploaddata))
+		return -1;
+
+	/* Parse RCTICKET */
+	if (!freerdp_assistance_parse_attr_str(&file->RCTicket, "RCTICKET", uploaddata))
+		return -1;
+
+	/* Parse RCTICKETENCRYPTED */
+	if (!freerdp_assistance_parse_attr_bool(&file->RCTicketEncrypted, "RCTICKETENCRYPTED",
+	                                        uploaddata))
+		return -1;
+
+	/* Parse PassStub */
+	if (!freerdp_assistance_parse_attr_str(&file->PassStub, "PassStub", uploaddata))
+		return -1;
+
+	if (file->PassStub)
+	{
+		const char* amp = "&amp;";
+		char* passtub = strstr(file->PassStub, amp);
+		while (passtub)
+		{
+			const char* end = passtub + 5;
+			const size_t len = strlen(end);
+			memmove(&passtub[1], end, len + 1);
+			passtub = strstr(passtub, amp);
+		}
+	}
+
+	/* Parse DtStart */
+	if (!freerdp_assistance_parse_attr_uint32(&file->DtStart, "DtStart", uploaddata))
+		return -1;
+
+	/* Parse DtLength */
+	if (!freerdp_assistance_parse_attr_uint32(&file->DtLength, "DtLength", uploaddata))
+		return -1;
+
+	/* Parse L (LowSpeed) */
+	if (!freerdp_assistance_parse_attr_bool(&file->LowSpeed, "L", uploaddata))
+		return -1;
+
+	file->Type = (file->LHTicket) ? 2 : 1;
+	int status = 0;
+
+	switch (file->Type)
+	{
+		case 2:
+		{
+			file->EncryptedLHTicket = freerdp_assistance_hex_string_to_bin(
+			    file->LHTicket, &file->EncryptedLHTicketLength);
+
+			if (!freerdp_assistance_decrypt2(file))
+				status = -1;
+		}
+		break;
+
+		case 1:
+		{
+			if (!freerdp_assistance_parse_connection_string1(file))
+				status = -1;
+		}
+		break;
+
+		default:
+			return -1;
+	}
+
+	if (status < 0)
+	{
+		WLog_ERR(TAG, "freerdp_assistance_parse_connection_string1 failure: %d", status);
+		return -1;
+	}
+
+	file->EncryptedPassStub = freerdp_assistance_encrypt_pass_stub(file->password, file->PassStub,
+	                                                               &file->EncryptedPassStubLength);
+
+	if (!file->EncryptedPassStub)
+		return -1;
+
+	return 1;
+}
+
+static int freerdp_assistance_parse_file_buffer_int(rdpAssistanceFile* file, char* buffer,
+                                                    size_t size, const char* password)
+{
+	WINPR_ASSERT(file);
+	WINPR_ASSERT(buffer);
+	WINPR_ASSERT(size > 0);
+
+	if (!update_password(file, password))
+		return -1;
+
+	char* uploadinfo = NULL;
+	size_t uploadinfosize = 0;
+	if (freerdp_assistance_consume_input_and_get_element(buffer, "UPLOADINFO", &uploadinfo,
+	                                                     &uploadinfosize))
+		return freerdp_assistance_parse_uploadinfo(file, uploadinfo, uploadinfosize);
+
+	size_t elen = 0;
+	const char* estr = freerdp_assistance_contains_element(buffer, size, "E", &elen, NULL, NULL);
+	if (!estr || (elen == 0))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Neither UPLOADINFO nor <E> found");
+		return -1;
+	}
+	if (!update_connectionstring2(file, estr, elen))
+		return -1;
+
+	if (!freerdp_assistance_parse_connection_string2(file))
+		return -1;
+
+	return 1;
+}
+
+int freerdp_assistance_parse_file_buffer(rdpAssistanceFile* file, const char* cbuffer, size_t size,
+                                         const char* password)
+{
+	WINPR_ASSERT(file);
+	if (!password)
+	{
+		WLog_WARN(TAG, "empty password supplied");
+	}
+
+	if (!cbuffer || (size == 0))
+	{
+		WLog_WARN(TAG, "no data supplied [%p, %" PRIuz "]", cbuffer, size);
+		return -1;
+	}
+
+	char* abuffer = strndup(cbuffer, size);
+	const size_t len = strnlen(cbuffer, size);
+	if (len == size)
+		WLog_WARN(TAG, "Input data not '\0' terminated");
+
+	if (!abuffer)
+		return -1;
+
+	const int rc = freerdp_assistance_parse_file_buffer_int(file, abuffer, len + 1, password);
+	free(abuffer);
+	return rc;
+}
+
+int freerdp_assistance_parse_file(rdpAssistanceFile* file, const char* name, const char* password)
+{
+	int status = 0;
+	BYTE* buffer = NULL;
+	FILE* fp = NULL;
+	size_t readSize = 0;
+	union
+	{
+		INT64 i64;
+		size_t s;
+	} fileSize;
+
+	if (!update_name(file, name))
+		return -1;
+
+	fp = winpr_fopen(name, "r");
+
+	if (!fp)
+	{
+		WLog_ERR(TAG, "Failed to open ASSISTANCE file %s ", name);
+		return -1;
+	}
+
+	(void)_fseeki64(fp, 0, SEEK_END);
+	fileSize.i64 = _ftelli64(fp);
+	(void)_fseeki64(fp, 0, SEEK_SET);
+
+	if (fileSize.i64 < 1)
+	{
+		WLog_ERR(TAG, "Failed to read ASSISTANCE file %s ", name);
+		(void)fclose(fp);
+		return -1;
+	}
+
+	buffer = (BYTE*)malloc(fileSize.s + 2);
+
+	if (!buffer)
+	{
+		(void)fclose(fp);
+		return -1;
+	}
+
+	readSize = fread(buffer, fileSize.s, 1, fp);
+
+	if (!readSize)
+	{
+		if (!ferror(fp))
+			readSize = fileSize.s;
+	}
+
+	(void)fclose(fp);
+
+	if (readSize < 1)
+	{
+		WLog_ERR(TAG, "Failed to read ASSISTANCE file %s ", name);
+		free(buffer);
+		buffer = NULL;
+		return -1;
+	}
+
+	buffer[fileSize.s] = '\0';
+	buffer[fileSize.s + 1] = '\0';
+	status = freerdp_assistance_parse_file_buffer(file, (char*)buffer, fileSize.s, password);
+	free(buffer);
+	return status;
+}
+
+BOOL freerdp_assistance_populate_settings_from_assistance_file(rdpAssistanceFile* file,
+                                                               rdpSettings* settings)
+{
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteAssistanceMode, TRUE))
+		return FALSE;
+
+	if (!file->RASessionId || !file->MachineAddresses)
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceSessionId,
+	                                 file->RASessionId))
+		return FALSE;
+
+	if (file->RCTicket)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceRCTicket,
+		                                 file->RCTicket))
+			return FALSE;
+	}
+	else
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceRCTicket,
+		                                 file->ConnectionString2))
+			return FALSE;
+	}
+
+	if (file->PassStub)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistancePassStub,
+		                                 file->PassStub))
+			return FALSE;
+	}
+
+	if (ArrayList_Count(file->MachineAddresses) < 1)
+		return FALSE;
+
+	const char* addr = ArrayList_GetItem(file->MachineAddresses, 0);
+	if (!freerdp_settings_set_string(settings, FreeRDP_ServerHostname, addr))
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_AssistanceFile, file->filename))
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistancePassword, file->password))
+		return FALSE;
+
+	if (file->Username)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_Username, file->Username))
+			return FALSE;
+	}
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteAssistanceMode, TRUE))
+		return FALSE;
+
+	const size_t ports = ArrayList_Count(file->MachinePorts);
+	const size_t addresses = ArrayList_Count(file->MachineAddresses);
+	if (ports < 1)
+		return FALSE;
+	if (ports != addresses)
+		return FALSE;
+
+	union
+	{
+		uintptr_t port;
+		void* data;
+	} cnv;
+	cnv.data = ArrayList_GetItem(file->MachinePorts, 0);
+	WINPR_ASSERT(cnv.port <= UINT32_MAX);
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, (UINT32)cnv.port))
+		return FALSE;
+
+	if (!freerdp_target_net_adresses_reset(settings, ports))
+		return FALSE;
+
+	for (size_t x = 0; x < ports; x++)
+	{
+		cnv.data = ArrayList_GetItem(file->MachinePorts, x);
+		WINPR_ASSERT(cnv.port <= UINT32_MAX);
+		const UINT32 port = (UINT32)cnv.port;
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetPorts, x, &port))
+			return FALSE;
+	}
+	for (size_t i = 0; i < addresses; i++)
+	{
+		const char* maddr = ArrayList_GetItem(file->MachineAddresses, i);
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i, maddr))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL setup_string(wArrayList* list)
+{
+	WINPR_ASSERT(list);
+
+	wObject* obj = ArrayList_Object(list);
+	if (!obj)
+		return FALSE;
+	obj->fnObjectFree = free;
+	// obj->fnObjectNew = wwinpr_ObjectStringClone;
+	return TRUE;
+}
+
+rdpAssistanceFile* freerdp_assistance_file_new(void)
+{
+	winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
+	rdpAssistanceFile* file = calloc(1, sizeof(rdpAssistanceFile));
+	if (!file)
+		return NULL;
+
+	file->MachineAddresses = ArrayList_New(FALSE);
+	file->MachinePorts = ArrayList_New(FALSE);
+	file->MachineUris = ArrayList_New(FALSE);
+
+	if (!file->MachineAddresses || !file->MachinePorts || !file->MachineUris)
+		goto fail;
+
+	if (!setup_string(file->MachineAddresses) || !setup_string(file->MachineUris))
+		goto fail;
+
+	return file;
+
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_assistance_file_free(file);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void freerdp_assistance_file_free(rdpAssistanceFile* file)
+{
+	if (!file)
+		return;
+
+	update_password(file, NULL);
+	update_connectionstring2(file, NULL, 0);
+	free(file->filename);
+	free(file->Username);
+	free(file->LHTicket);
+	free(file->RCTicket);
+	free(file->PassStub);
+	free(file->ConnectionString1);
+	free(file->EncryptedLHTicket);
+	free(file->RASessionId);
+	free(file->RASpecificParams);
+	free(file->RASpecificParams2);
+	free(file->EncryptedPassStub);
+
+	ArrayList_Free(file->MachineAddresses);
+	ArrayList_Free(file->MachinePorts);
+	ArrayList_Free(file->MachineUris);
+	free(file);
+}
+
+void freerdp_assistance_print_file(rdpAssistanceFile* file, wLog* log, DWORD level)
+{
+	WINPR_ASSERT(file);
+
+	WLog_Print(log, level, "Username: %s", file->Username);
+	WLog_Print(log, level, "LHTicket: %s", file->LHTicket);
+	WLog_Print(log, level, "RCTicket: %s", file->RCTicket);
+	WLog_Print(log, level, "RCTicketEncrypted: %" PRId32, file->RCTicketEncrypted);
+	WLog_Print(log, level, "PassStub: %s", file->PassStub);
+	WLog_Print(log, level, "DtStart: %" PRIu32, file->DtStart);
+	WLog_Print(log, level, "DtLength: %" PRIu32, file->DtLength);
+	WLog_Print(log, level, "LowSpeed: %" PRId32, file->LowSpeed);
+	WLog_Print(log, level, "RASessionId: %s", file->RASessionId);
+	WLog_Print(log, level, "RASpecificParams: %s", file->RASpecificParams);
+	WLog_Print(log, level, "RASpecificParams2: %s", file->RASpecificParams2);
+
+	for (size_t x = 0; x < ArrayList_Count(file->MachineAddresses); x++)
+	{
+		UINT32 port = 0;
+		const char* uri = NULL;
+		const char* addr = ArrayList_GetItem(file->MachineAddresses, x);
+		if (x < ArrayList_Count(file->MachinePorts))
+		{
+			union
+			{
+				uintptr_t port;
+				void* data;
+			} cnv;
+			cnv.data = ArrayList_GetItem(file->MachinePorts, x);
+			WINPR_ASSERT(cnv.port <= UINT32_MAX);
+			port = (UINT32)cnv.port;
+		}
+		if (x < ArrayList_Count(file->MachineUris))
+			uri = ArrayList_GetItem(file->MachineUris, x);
+
+		WLog_Print(log, level, "MachineAddress [%" PRIdz ": %s", x, addr);
+		WLog_Print(log, level, "MachinePort    [%" PRIdz ": %" PRIu32, x, port);
+		WLog_Print(log, level, "MachineURI     [%" PRIdz ": %s", x, uri);
+	}
+}
+
+BOOL freerdp_assistance_get_encrypted_pass_stub(rdpAssistanceFile* file, const char** pwd,
+                                                size_t* size)
+{
+	if (!file || !pwd || !size)
+		return FALSE;
+
+	*pwd = (const char*)file->EncryptedPassStub;
+	*size = file->EncryptedPassStubLength;
+	return TRUE;
+}
+
+int freerdp_assistance_set_connection_string2(rdpAssistanceFile* file, const char* string,
+                                              const char* password)
+{
+	if (!file || !string || !password)
+		return -1;
+
+	char* str = _strdup(string);
+	if (!str)
+		return -1;
+
+	if (!update_connectionstring2_nocopy(file, str))
+		return -1;
+	if (!update_password(file, password))
+		return -1;
+	return freerdp_assistance_parse_connection_string2(file);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/common/settings_str.h

@@ -0,0 +1,629 @@
+/* Generated by  */
+
+#ifndef FREERDP_CORE_SETTINGS_STR_H
+#define FREERDP_CORE_SETTINGS_STR_H
+
+#include "../core/settings.h"
+
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("common.settings")
+
+typedef enum
+{
+	FREERDP_SETTINGS_TYPE_BOOL,
+	FREERDP_SETTINGS_TYPE_UINT16,
+	FREERDP_SETTINGS_TYPE_INT16,
+	FREERDP_SETTINGS_TYPE_UINT32,
+	FREERDP_SETTINGS_TYPE_INT32,
+	FREERDP_SETTINGS_TYPE_UINT64,
+	FREERDP_SETTINGS_TYPE_INT64,
+	FREERDP_SETTINGS_TYPE_STRING,
+	FREERDP_SETTINGS_TYPE_POINTER
+} FREERDP_SETTINGS_TYPE;
+
+struct settings_str_entry
+{
+	SSIZE_T id;
+	SSIZE_T type;
+	const char* str;
+};
+static const struct settings_str_entry settings_map[] = {
+	{ FreeRDP_AadSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AadSecurity" },
+	{ FreeRDP_AllowCacheWaitingList, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AllowCacheWaitingList" },
+	{ FreeRDP_AllowDesktopComposition, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AllowDesktopComposition" },
+	{ FreeRDP_AllowFontSmoothing, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AllowFontSmoothing" },
+	{ FreeRDP_AllowUnanouncedOrdersFromServer, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AllowUnanouncedOrdersFromServer" },
+	{ FreeRDP_AltSecFrameMarkerSupport, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AltSecFrameMarkerSupport" },
+	{ FreeRDP_AsyncChannels, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AsyncChannels" },
+	{ FreeRDP_AsyncUpdate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AsyncUpdate" },
+	{ FreeRDP_AudioCapture, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AudioCapture" },
+	{ FreeRDP_AudioPlayback, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AudioPlayback" },
+	{ FreeRDP_Authentication, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Authentication" },
+	{ FreeRDP_AuthenticationOnly, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AuthenticationOnly" },
+	{ FreeRDP_AutoAcceptCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoAcceptCertificate" },
+	{ FreeRDP_AutoDenyCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoDenyCertificate" },
+	{ FreeRDP_AutoLogonEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoLogonEnabled" },
+	{ FreeRDP_AutoReconnectionEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AutoReconnectionEnabled" },
+	{ FreeRDP_AutoReconnectionPacketSupported, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AutoReconnectionPacketSupported" },
+	{ FreeRDP_BitmapCacheEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_BitmapCacheEnabled" },
+	{ FreeRDP_BitmapCachePersistEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_BitmapCachePersistEnabled" },
+	{ FreeRDP_BitmapCacheV3Enabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_BitmapCacheV3Enabled" },
+	{ FreeRDP_BitmapCompressionDisabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_BitmapCompressionDisabled" },
+	{ FreeRDP_CertificateCallbackPreferPEM, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_CertificateCallbackPreferPEM" },
+	{ FreeRDP_CompressionEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_CompressionEnabled" },
+	{ FreeRDP_ConnectChildSession, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ConnectChildSession" },
+	{ FreeRDP_ConsoleSession, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ConsoleSession" },
+	{ FreeRDP_CredentialsFromStdin, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_CredentialsFromStdin" },
+	{ FreeRDP_DeactivateClientDecoding, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DeactivateClientDecoding" },
+	{ FreeRDP_Decorations, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Decorations" },
+	{ FreeRDP_DesktopResize, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DesktopResize" },
+	{ FreeRDP_DeviceRedirection, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DeviceRedirection" },
+	{ FreeRDP_DisableCredentialsDelegation, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DisableCredentialsDelegation" },
+	{ FreeRDP_DisableCtrlAltDel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCtrlAltDel" },
+	{ FreeRDP_DisableCursorBlinking, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCursorBlinking" },
+	{ FreeRDP_DisableCursorShadow, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCursorShadow" },
+	{ FreeRDP_DisableFullWindowDrag, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableFullWindowDrag" },
+	{ FreeRDP_DisableMenuAnims, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableMenuAnims" },
+	{ FreeRDP_DisableRemoteAppCapsCheck, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DisableRemoteAppCapsCheck" },
+	{ FreeRDP_DisableThemes, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableThemes" },
+	{ FreeRDP_DisableWallpaper, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableWallpaper" },
+	{ FreeRDP_DrawAllowColorSubsampling, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawAllowColorSubsampling" },
+	{ FreeRDP_DrawAllowDynamicColorFidelity, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawAllowDynamicColorFidelity" },
+	{ FreeRDP_DrawAllowSkipAlpha, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawAllowSkipAlpha" },
+	{ FreeRDP_DrawGdiPlusCacheEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawGdiPlusCacheEnabled" },
+	{ FreeRDP_DrawGdiPlusEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawGdiPlusEnabled" },
+	{ FreeRDP_DrawNineGridEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawNineGridEnabled" },
+	{ FreeRDP_DumpRemoteFx, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DumpRemoteFx" },
+	{ FreeRDP_DynamicDaylightTimeDisabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DynamicDaylightTimeDisabled" },
+	{ FreeRDP_DynamicResolutionUpdate, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DynamicResolutionUpdate" },
+	{ FreeRDP_EmbeddedWindow, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EmbeddedWindow" },
+	{ FreeRDP_EnableWindowsKey, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EnableWindowsKey" },
+	{ FreeRDP_EncomspVirtualChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EncomspVirtualChannel" },
+	{ FreeRDP_ExtSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ExtSecurity" },
+	{ FreeRDP_ExternalCertificateManagement, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_ExternalCertificateManagement" },
+	{ FreeRDP_FIPSMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FIPSMode" },
+	{ FreeRDP_FastPathInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FastPathInput" },
+	{ FreeRDP_FastPathOutput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FastPathOutput" },
+	{ FreeRDP_ForceEncryptedCsPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ForceEncryptedCsPdu" },
+	{ FreeRDP_ForceMultimon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ForceMultimon" },
+	{ FreeRDP_FrameMarkerCommandEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_FrameMarkerCommandEnabled" },
+	{ FreeRDP_Fullscreen, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Fullscreen" },
+	{ FreeRDP_GatewayArmTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayArmTransport" },
+	{ FreeRDP_GatewayAvdUseTenantid, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayAvdUseTenantid" },
+	{ FreeRDP_GatewayBypassLocal, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayBypassLocal" },
+	{ FreeRDP_GatewayEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayEnabled" },
+	{ FreeRDP_GatewayHttpExtAuthSspiNtlm, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayHttpExtAuthSspiNtlm" },
+	{ FreeRDP_GatewayHttpTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayHttpTransport" },
+	{ FreeRDP_GatewayHttpUseWebsockets, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayHttpUseWebsockets" },
+	{ FreeRDP_GatewayIgnoreRedirectionPolicy, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayIgnoreRedirectionPolicy" },
+	{ FreeRDP_GatewayRpcTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayRpcTransport" },
+	{ FreeRDP_GatewayUdpTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayUdpTransport" },
+	{ FreeRDP_GatewayUseSameCredentials, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayUseSameCredentials" },
+	{ FreeRDP_GfxAVC444, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxAVC444" },
+	{ FreeRDP_GfxAVC444v2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxAVC444v2" },
+	{ FreeRDP_GfxH264, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxH264" },
+	{ FreeRDP_GfxPlanar, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxPlanar" },
+	{ FreeRDP_GfxProgressive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxProgressive" },
+	{ FreeRDP_GfxProgressiveV2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxProgressiveV2" },
+	{ FreeRDP_GfxSendQoeAck, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxSendQoeAck" },
+	{ FreeRDP_GfxSmallCache, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxSmallCache" },
+	{ FreeRDP_GfxSuspendFrameAck, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxSuspendFrameAck" },
+	{ FreeRDP_GfxThinClient, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxThinClient" },
+	{ FreeRDP_GrabKeyboard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GrabKeyboard" },
+	{ FreeRDP_GrabMouse, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GrabMouse" },
+	{ FreeRDP_HasExtendedMouseEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasExtendedMouseEvent" },
+	{ FreeRDP_HasHorizontalWheel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasHorizontalWheel" },
+	{ FreeRDP_HasMonitorAttributes, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasMonitorAttributes" },
+	{ FreeRDP_HasQoeEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasQoeEvent" },
+	{ FreeRDP_HasRelativeMouseEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasRelativeMouseEvent" },
+	{ FreeRDP_HiDefRemoteApp, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HiDefRemoteApp" },
+	{ FreeRDP_IPv6Enabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IPv6Enabled" },
+	{ FreeRDP_IgnoreCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IgnoreCertificate" },
+	{ FreeRDP_IgnoreInvalidDevices, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IgnoreInvalidDevices" },
+	{ FreeRDP_JpegCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_JpegCodec" },
+	{ FreeRDP_KerberosRdgIsProxy, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_KerberosRdgIsProxy" },
+	{ FreeRDP_ListMonitors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ListMonitors" },
+	{ FreeRDP_LocalConnection, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LocalConnection" },
+	{ FreeRDP_LogonErrors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LogonErrors" },
+	{ FreeRDP_LogonNotify, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LogonNotify" },
+	{ FreeRDP_LongCredentialsSupported, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_LongCredentialsSupported" },
+	{ FreeRDP_LyncRdpMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LyncRdpMode" },
+	{ FreeRDP_MaximizeShell, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MaximizeShell" },
+	{ FreeRDP_MouseAttached, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseAttached" },
+	{ FreeRDP_MouseHasWheel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseHasWheel" },
+	{ FreeRDP_MouseMotion, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseMotion" },
+	{ FreeRDP_MouseUseRelativeMove, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseUseRelativeMove" },
+	{ FreeRDP_MstscCookieMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MstscCookieMode" },
+	{ FreeRDP_MultiTouchGestures, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MultiTouchGestures" },
+	{ FreeRDP_MultiTouchInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MultiTouchInput" },
+	{ FreeRDP_NSCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NSCodec" },
+	{ FreeRDP_NSCodecAllowDynamicColorFidelity, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NSCodecAllowDynamicColorFidelity" },
+	{ FreeRDP_NSCodecAllowSubsampling, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NSCodecAllowSubsampling" },
+	{ FreeRDP_NegotiateSecurityLayer, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NegotiateSecurityLayer" },
+	{ FreeRDP_NetworkAutoDetect, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NetworkAutoDetect" },
+	{ FreeRDP_NlaSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NlaSecurity" },
+	{ FreeRDP_NoBitmapCompressionHeader, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NoBitmapCompressionHeader" },
+	{ FreeRDP_OldLicenseBehaviour, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_OldLicenseBehaviour" },
+	{ FreeRDP_PasswordIsSmartcardPin, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_PasswordIsSmartcardPin" },
+	{ FreeRDP_PercentScreenUseHeight, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_PercentScreenUseHeight" },
+	{ FreeRDP_PercentScreenUseWidth, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PercentScreenUseWidth" },
+	{ FreeRDP_PlayRemoteFx, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PlayRemoteFx" },
+	{ FreeRDP_PreferIPv6OverIPv4, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PreferIPv6OverIPv4" },
+	{ FreeRDP_PrintReconnectCookie, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PrintReconnectCookie" },
+	{ FreeRDP_PromptForCredentials, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PromptForCredentials" },
+	{ FreeRDP_RdpSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RdpSecurity" },
+	{ FreeRDP_RdstlsSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RdstlsSecurity" },
+	{ FreeRDP_RedirectClipboard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectClipboard" },
+	{ FreeRDP_RedirectDrives, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectDrives" },
+	{ FreeRDP_RedirectHomeDrive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectHomeDrive" },
+	{ FreeRDP_RedirectParallelPorts, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectParallelPorts" },
+	{ FreeRDP_RedirectPrinters, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectPrinters" },
+	{ FreeRDP_RedirectSerialPorts, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectSerialPorts" },
+	{ FreeRDP_RedirectSmartCards, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectSmartCards" },
+	{ FreeRDP_RedirectWebAuthN, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectWebAuthN" },
+	{ FreeRDP_RefreshRect, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RefreshRect" },
+	{ FreeRDP_RemdeskVirtualChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemdeskVirtualChannel" },
+	{ FreeRDP_RemoteAppLanguageBarSupported, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RemoteAppLanguageBarSupported" },
+	{ FreeRDP_RemoteApplicationMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteApplicationMode" },
+	{ FreeRDP_RemoteAssistanceMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteAssistanceMode" },
+	{ FreeRDP_RemoteAssistanceRequestControl, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RemoteAssistanceRequestControl" },
+	{ FreeRDP_RemoteConsoleAudio, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteConsoleAudio" },
+	{ FreeRDP_RemoteCredentialGuard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteCredentialGuard" },
+	{ FreeRDP_RemoteFxCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxCodec" },
+	{ FreeRDP_RemoteFxImageCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxImageCodec" },
+	{ FreeRDP_RemoteFxOnly, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxOnly" },
+	{ FreeRDP_RestrictedAdminModeRequired, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RestrictedAdminModeRequired" },
+	{ FreeRDP_SaltedChecksum, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SaltedChecksum" },
+	{ FreeRDP_SendPreconnectionPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SendPreconnectionPdu" },
+	{ FreeRDP_ServerLicenseRequired, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ServerLicenseRequired" },
+	{ FreeRDP_ServerMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ServerMode" },
+	{ FreeRDP_SmartSizing, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartSizing" },
+	{ FreeRDP_SmartcardEmulation, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartcardEmulation" },
+	{ FreeRDP_SmartcardLogon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartcardLogon" },
+	{ FreeRDP_SoftwareGdi, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SoftwareGdi" },
+	{ FreeRDP_SoundBeepsEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SoundBeepsEnabled" },
+	{ FreeRDP_SpanMonitors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SpanMonitors" },
+	{ FreeRDP_SupportAsymetricKeys, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportAsymetricKeys" },
+	{ FreeRDP_SupportDisplayControl, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportDisplayControl" },
+	{ FreeRDP_SupportDynamicChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportDynamicChannels" },
+	{ FreeRDP_SupportDynamicTimeZone, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportDynamicTimeZone" },
+	{ FreeRDP_SupportEchoChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEchoChannel" },
+	{ FreeRDP_SupportEdgeActionV1, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEdgeActionV1" },
+	{ FreeRDP_SupportEdgeActionV2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEdgeActionV2" },
+	{ FreeRDP_SupportErrorInfoPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportErrorInfoPdu" },
+	{ FreeRDP_SupportGeometryTracking, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportGeometryTracking" },
+	{ FreeRDP_SupportGraphicsPipeline, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportGraphicsPipeline" },
+	{ FreeRDP_SupportHeartbeatPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportHeartbeatPdu" },
+	{ FreeRDP_SupportMonitorLayoutPdu, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportMonitorLayoutPdu" },
+	{ FreeRDP_SupportMultitransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportMultitransport" },
+	{ FreeRDP_SupportSSHAgentChannel, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportSSHAgentChannel" },
+	{ FreeRDP_SupportSkipChannelJoin, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportSkipChannelJoin" },
+	{ FreeRDP_SupportStatusInfoPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportStatusInfoPdu" },
+	{ FreeRDP_SupportVideoOptimized, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportVideoOptimized" },
+	{ FreeRDP_SuppressOutput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SuppressOutput" },
+	{ FreeRDP_SurfaceCommandsEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SurfaceCommandsEnabled" },
+	{ FreeRDP_SurfaceFrameMarkerEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SurfaceFrameMarkerEnabled" },
+	{ FreeRDP_SuspendInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SuspendInput" },
+	{ FreeRDP_SynchronousDynamicChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SynchronousDynamicChannels" },
+	{ FreeRDP_SynchronousStaticChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SynchronousStaticChannels" },
+	{ FreeRDP_TcpKeepAlive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TcpKeepAlive" },
+	{ FreeRDP_TlsSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TlsSecurity" },
+	{ FreeRDP_ToggleFullscreen, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ToggleFullscreen" },
+	{ FreeRDP_TransportDump, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TransportDump" },
+	{ FreeRDP_TransportDumpReplay, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TransportDumpReplay" },
+	{ FreeRDP_TransportDumpReplayNodelay, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_TransportDumpReplayNodelay" },
+	{ FreeRDP_UnicodeInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UnicodeInput" },
+	{ FreeRDP_UnmapButtons, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UnmapButtons" },
+	{ FreeRDP_UseCommonStdioCallbacks, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_UseCommonStdioCallbacks" },
+	{ FreeRDP_UseMultimon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UseMultimon" },
+	{ FreeRDP_UseRdpSecurityLayer, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UseRdpSecurityLayer" },
+	{ FreeRDP_UsingSavedCredentials, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UsingSavedCredentials" },
+	{ FreeRDP_VideoDisable, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_VideoDisable" },
+	{ FreeRDP_VmConnectMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_VmConnectMode" },
+	{ FreeRDP_WaitForOutputBufferFlush, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_WaitForOutputBufferFlush" },
+	{ FreeRDP_Workarea, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Workarea" },
+	{ FreeRDP_CapsGeneralCompressionLevel, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsGeneralCompressionLevel" },
+	{ FreeRDP_CapsGeneralCompressionTypes, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsGeneralCompressionTypes" },
+	{ FreeRDP_CapsProtocolVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_CapsProtocolVersion" },
+	{ FreeRDP_CapsRemoteUnshareFlag, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsRemoteUnshareFlag" },
+	{ FreeRDP_CapsUpdateCapabilityFlag, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsUpdateCapabilityFlag" },
+	{ FreeRDP_DesktopOrientation, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_DesktopOrientation" },
+	{ FreeRDP_OrderSupportFlags, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_OrderSupportFlags" },
+	{ FreeRDP_OrderSupportFlagsEx, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_OrderSupportFlagsEx" },
+	{ FreeRDP_ProxyPort, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_ProxyPort" },
+	{ FreeRDP_SupportedColorDepths, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_SupportedColorDepths" },
+	{ FreeRDP_TLSMaxVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TLSMaxVersion" },
+	{ FreeRDP_TLSMinVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TLSMinVersion" },
+	{ FreeRDP_TextANSICodePage, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TextANSICodePage" },
+	{ FreeRDP_AcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_AcceptedCertLength" },
+	{ FreeRDP_AuthenticationLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_AuthenticationLevel" },
+	{ FreeRDP_AutoReconnectMaxRetries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_AutoReconnectMaxRetries" },
+	{ FreeRDP_BitmapCacheV2NumCells, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_BitmapCacheV2NumCells" },
+	{ FreeRDP_BitmapCacheV3CodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BitmapCacheV3CodecId" },
+	{ FreeRDP_BitmapCacheVersion, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BitmapCacheVersion" },
+	{ FreeRDP_BrushSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BrushSupportLevel" },
+	{ FreeRDP_ChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ChannelCount" },
+	{ FreeRDP_ChannelDefArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ChannelDefArraySize" },
+	{ FreeRDP_ClientBuild, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientBuild" },
+	{ FreeRDP_ClientRandomLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientRandomLength" },
+	{ FreeRDP_ClientSessionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientSessionId" },
+	{ FreeRDP_ClipboardFeatureMask, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClipboardFeatureMask" },
+	{ FreeRDP_ClusterInfoFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClusterInfoFlags" },
+	{ FreeRDP_ColorDepth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ColorDepth" },
+	{ FreeRDP_ColorPointerCacheSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ColorPointerCacheSize" },
+	{ FreeRDP_CompDeskSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CompDeskSupportLevel" },
+	{ FreeRDP_CompressionLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CompressionLevel" },
+	{ FreeRDP_ConnectionType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ConnectionType" },
+	{ FreeRDP_CookieMaxLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CookieMaxLength" },
+	{ FreeRDP_DesktopHeight, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopHeight" },
+	{ FreeRDP_DesktopPhysicalHeight, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DesktopPhysicalHeight" },
+	{ FreeRDP_DesktopPhysicalWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPhysicalWidth" },
+	{ FreeRDP_DesktopPosX, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPosX" },
+	{ FreeRDP_DesktopPosY, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPosY" },
+	{ FreeRDP_DesktopScaleFactor, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopScaleFactor" },
+	{ FreeRDP_DesktopWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopWidth" },
+	{ FreeRDP_DeviceArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceArraySize" },
+	{ FreeRDP_DeviceCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceCount" },
+	{ FreeRDP_DeviceScaleFactor, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceScaleFactor" },
+	{ FreeRDP_DrawNineGridCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DrawNineGridCacheEntries" },
+	{ FreeRDP_DrawNineGridCacheSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DrawNineGridCacheSize" },
+	{ FreeRDP_DynamicChannelArraySize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DynamicChannelArraySize" },
+	{ FreeRDP_DynamicChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DynamicChannelCount" },
+	{ FreeRDP_EarlyCapabilityFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EarlyCapabilityFlags" },
+	{ FreeRDP_EncryptionLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EncryptionLevel" },
+	{ FreeRDP_EncryptionMethods, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EncryptionMethods" },
+	{ FreeRDP_ExtEncryptionMethods, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ExtEncryptionMethods" },
+	{ FreeRDP_FakeMouseMotionInterval, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_FakeMouseMotionInterval" },
+	{ FreeRDP_Floatbar, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_Floatbar" },
+	{ FreeRDP_ForceIPvX, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ForceIPvX" },
+	{ FreeRDP_FrameAcknowledge, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_FrameAcknowledge" },
+	{ FreeRDP_GatewayAcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_GatewayAcceptedCertLength" },
+	{ FreeRDP_GatewayCredentialsSource, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_GatewayCredentialsSource" },
+	{ FreeRDP_GatewayPort, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GatewayPort" },
+	{ FreeRDP_GatewayUsageMethod, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GatewayUsageMethod" },
+	{ FreeRDP_GfxCapsFilter, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GfxCapsFilter" },
+	{ FreeRDP_GlyphSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GlyphSupportLevel" },
+	{ FreeRDP_JpegCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_JpegCodecId" },
+	{ FreeRDP_JpegQuality, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_JpegQuality" },
+	{ FreeRDP_KeySpec, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeySpec" },
+	{ FreeRDP_KeyboardCodePage, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardCodePage" },
+	{ FreeRDP_KeyboardFunctionKey, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardFunctionKey" },
+	{ FreeRDP_KeyboardHook, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardHook" },
+	{ FreeRDP_KeyboardLayout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardLayout" },
+	{ FreeRDP_KeyboardSubType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardSubType" },
+	{ FreeRDP_KeyboardType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardType" },
+	{ FreeRDP_LargePointerFlag, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_LargePointerFlag" },
+	{ FreeRDP_LoadBalanceInfoLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_LoadBalanceInfoLength" },
+	{ FreeRDP_MonitorAttributeFlags, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_MonitorAttributeFlags" },
+	{ FreeRDP_MonitorCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorCount" },
+	{ FreeRDP_MonitorDefArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorDefArraySize" },
+	{ FreeRDP_MonitorFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorFlags" },
+	{ FreeRDP_MonitorLocalShiftX, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorLocalShiftX" },
+	{ FreeRDP_MonitorLocalShiftY, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorLocalShiftY" },
+	{ FreeRDP_MultifragMaxRequestSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_MultifragMaxRequestSize" },
+	{ FreeRDP_MultitransportFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MultitransportFlags" },
+	{ FreeRDP_NSCodecColorLossLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_NSCodecColorLossLevel" },
+	{ FreeRDP_NSCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NSCodecId" },
+	{ FreeRDP_NegotiationFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NegotiationFlags" },
+	{ FreeRDP_NumMonitorIds, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NumMonitorIds" },
+	{ FreeRDP_OffscreenCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_OffscreenCacheEntries" },
+	{ FreeRDP_OffscreenCacheSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OffscreenCacheSize" },
+	{ FreeRDP_OffscreenSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_OffscreenSupportLevel" },
+	{ FreeRDP_OsMajorType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OsMajorType" },
+	{ FreeRDP_OsMinorType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OsMinorType" },
+	{ FreeRDP_Password51Length, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_Password51Length" },
+	{ FreeRDP_PduSource, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PduSource" },
+	{ FreeRDP_PercentScreen, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PercentScreen" },
+	{ FreeRDP_PerformanceFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PerformanceFlags" },
+	{ FreeRDP_PointerCacheSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PointerCacheSize" },
+	{ FreeRDP_PreconnectionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PreconnectionId" },
+	{ FreeRDP_ProxyType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ProxyType" },
+	{ FreeRDP_RdpVersion, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RdpVersion" },
+	{ FreeRDP_ReceivedCapabilitiesSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ReceivedCapabilitiesSize" },
+	{ FreeRDP_RedirectedSessionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RedirectedSessionId" },
+	{ FreeRDP_RedirectionAcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionAcceptedCertLength" },
+	{ FreeRDP_RedirectionFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RedirectionFlags" },
+	{ FreeRDP_RedirectionGuidLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionGuidLength" },
+	{ FreeRDP_RedirectionPasswordLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionPasswordLength" },
+	{ FreeRDP_RedirectionPreferType, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionPreferType" },
+	{ FreeRDP_RedirectionTsvUrlLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionTsvUrlLength" },
+	{ FreeRDP_RemoteAppNumIconCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteAppNumIconCacheEntries" },
+	{ FreeRDP_RemoteAppNumIconCaches, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteAppNumIconCaches" },
+	{ FreeRDP_RemoteApplicationExpandCmdLine, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationExpandCmdLine" },
+	{ FreeRDP_RemoteApplicationExpandWorkingDir, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationExpandWorkingDir" },
+	{ FreeRDP_RemoteApplicationSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationSupportLevel" },
+	{ FreeRDP_RemoteApplicationSupportMask, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationSupportMask" },
+	{ FreeRDP_RemoteFxCaptureFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCaptureFlags" },
+	{ FreeRDP_RemoteFxCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCodecId" },
+	{ FreeRDP_RemoteFxCodecMode, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCodecMode" },
+	{ FreeRDP_RemoteFxRlgrMode, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxRlgrMode" },
+	{ FreeRDP_RemoteWndSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteWndSupportLevel" },
+	{ FreeRDP_RequestedProtocols, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RequestedProtocols" },
+	{ FreeRDP_SelectedProtocol, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SelectedProtocol" },
+	{ FreeRDP_ServerCertificateLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerCertificateLength" },
+	{ FreeRDP_ServerLicenseProductIssuersCount, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerLicenseProductIssuersCount" },
+	{ FreeRDP_ServerLicenseProductVersion, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerLicenseProductVersion" },
+	{ FreeRDP_ServerPort, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ServerPort" },
+	{ FreeRDP_ServerRandomLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ServerRandomLength" },
+	{ FreeRDP_ShareId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ShareId" },
+	{ FreeRDP_SmartSizingHeight, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SmartSizingHeight" },
+	{ FreeRDP_SmartSizingWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SmartSizingWidth" },
+	{ FreeRDP_StaticChannelArraySize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_StaticChannelArraySize" },
+	{ FreeRDP_StaticChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_StaticChannelCount" },
+	{ FreeRDP_SurfaceCommandsSupported, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_SurfaceCommandsSupported" },
+	{ FreeRDP_TargetNetAddressCount, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_TargetNetAddressCount" },
+	{ FreeRDP_TcpAckTimeout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpAckTimeout" },
+	{ FreeRDP_TcpConnectTimeout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpConnectTimeout" },
+	{ FreeRDP_TcpKeepAliveDelay, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveDelay" },
+	{ FreeRDP_TcpKeepAliveInterval, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveInterval" },
+	{ FreeRDP_TcpKeepAliveRetries, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveRetries" },
+	{ FreeRDP_ThreadingFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ThreadingFlags" },
+	{ FreeRDP_TlsSecLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TlsSecLevel" },
+	{ FreeRDP_VCChunkSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_VCChunkSize" },
+	{ FreeRDP_VCFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_VCFlags" },
+	{ FreeRDP_MonitorLocalShiftX, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_MonitorLocalShiftX" },
+	{ FreeRDP_MonitorLocalShiftY, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_MonitorLocalShiftY" },
+	{ FreeRDP_XPan, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_XPan" },
+	{ FreeRDP_YPan, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_YPan" },
+	{ FreeRDP_ParentWindowId, FREERDP_SETTINGS_TYPE_UINT64, "FreeRDP_ParentWindowId" },
+	{ FreeRDP_AadServerHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AadServerHostname" },
+	{ FreeRDP_AcceptedCert, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AcceptedCert" },
+	{ FreeRDP_ActionScript, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ActionScript" },
+	{ FreeRDP_AllowedTlsCiphers, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AllowedTlsCiphers" },
+	{ FreeRDP_AlternateShell, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AlternateShell" },
+	{ FreeRDP_AssistanceFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AssistanceFile" },
+	{ FreeRDP_AuthenticationPackageList, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_AuthenticationPackageList" },
+	{ FreeRDP_AuthenticationServiceClass, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_AuthenticationServiceClass" },
+	{ FreeRDP_BitmapCachePersistFile, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_BitmapCachePersistFile" },
+	{ FreeRDP_CardName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CardName" },
+	{ FreeRDP_CertificateAcceptedFingerprints, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_CertificateAcceptedFingerprints" },
+	{ FreeRDP_CertificateName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CertificateName" },
+	{ FreeRDP_ClientAddress, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientAddress" },
+	{ FreeRDP_ClientDir, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientDir" },
+	{ FreeRDP_ClientHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientHostname" },
+	{ FreeRDP_ClientProductId, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientProductId" },
+	{ FreeRDP_ClipboardUseSelection, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ClipboardUseSelection" },
+	{ FreeRDP_ComputerName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ComputerName" },
+	{ FreeRDP_ConfigPath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ConfigPath" },
+	{ FreeRDP_ConnectionFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ConnectionFile" },
+	{ FreeRDP_ContainerName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ContainerName" },
+	{ FreeRDP_CspName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CspName" },
+	{ FreeRDP_CurrentPath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CurrentPath" },
+	{ FreeRDP_Domain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Domain" },
+	{ FreeRDP_DrivesToRedirect, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_DrivesToRedirect" },
+	{ FreeRDP_DumpRemoteFxFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_DumpRemoteFxFile" },
+	{ FreeRDP_DynamicDSTTimeZoneKeyName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_DynamicDSTTimeZoneKeyName" },
+	{ FreeRDP_GatewayAcceptedCert, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAcceptedCert" },
+	{ FreeRDP_GatewayAccessToken, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAccessToken" },
+	{ FreeRDP_GatewayAvdAadtenantid, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdAadtenantid" },
+	{ FreeRDP_GatewayAvdActivityhint, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdActivityhint" },
+	{ FreeRDP_GatewayAvdArmpath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAvdArmpath" },
+	{ FreeRDP_GatewayAvdClientID, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAvdClientID" },
+	{ FreeRDP_GatewayAvdDiagnosticserviceurl, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdDiagnosticserviceurl" },
+	{ FreeRDP_GatewayAvdGeo, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAvdGeo" },
+	{ FreeRDP_GatewayAvdHubdiscoverygeourl, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdHubdiscoverygeourl" },
+	{ FreeRDP_GatewayAvdWvdEndpointPool, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdWvdEndpointPool" },
+	{ FreeRDP_GatewayAzureActiveDirectory, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAzureActiveDirectory" },
+	{ FreeRDP_GatewayDomain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayDomain" },
+	{ FreeRDP_GatewayHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayHostname" },
+	{ FreeRDP_GatewayHttpExtAuthBearer, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayHttpExtAuthBearer" },
+	{ FreeRDP_GatewayPassword, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayPassword" },
+	{ FreeRDP_GatewayUrl, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayUrl" },
+	{ FreeRDP_GatewayUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayUsername" },
+	{ FreeRDP_HomePath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_HomePath" },
+	{ FreeRDP_ImeFileName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ImeFileName" },
+	{ FreeRDP_KerberosArmor, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosArmor" },
+	{ FreeRDP_KerberosCache, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosCache" },
+	{ FreeRDP_KerberosKdcUrl, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosKdcUrl" },
+	{ FreeRDP_KerberosKeytab, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosKeytab" },
+	{ FreeRDP_KerberosLifeTime, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosLifeTime" },
+	{ FreeRDP_KerberosRealm, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosRealm" },
+	{ FreeRDP_KerberosRenewableLifeTime, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_KerberosRenewableLifeTime" },
+	{ FreeRDP_KerberosStartTime, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosStartTime" },
+	{ FreeRDP_KeyboardPipeName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KeyboardPipeName" },
+	{ FreeRDP_KeyboardRemappingList, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_KeyboardRemappingList" },
+	{ FreeRDP_NtlmSamFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_NtlmSamFile" },
+	{ FreeRDP_Password, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Password" },
+	{ FreeRDP_PasswordHash, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PasswordHash" },
+	{ FreeRDP_Pkcs11Module, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Pkcs11Module" },
+	{ FreeRDP_PkinitAnchors, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PkinitAnchors" },
+	{ FreeRDP_PlayRemoteFxFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PlayRemoteFxFile" },
+	{ FreeRDP_PreconnectionBlob, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PreconnectionBlob" },
+	{ FreeRDP_ProxyHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyHostname" },
+	{ FreeRDP_ProxyPassword, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyPassword" },
+	{ FreeRDP_ProxyUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyUsername" },
+	{ FreeRDP_RDP2TCPArgs, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RDP2TCPArgs" },
+	{ FreeRDP_ReaderName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ReaderName" },
+	{ FreeRDP_RedirectionAcceptedCert, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionAcceptedCert" },
+	{ FreeRDP_RedirectionDomain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RedirectionDomain" },
+	{ FreeRDP_RedirectionTargetFQDN, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionTargetFQDN" },
+	{ FreeRDP_RedirectionTargetNetBiosName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionTargetNetBiosName" },
+	{ FreeRDP_RedirectionUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RedirectionUsername" },
+	{ FreeRDP_RemoteApplicationCmdLine, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationCmdLine" },
+	{ FreeRDP_RemoteApplicationFile, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationFile" },
+	{ FreeRDP_RemoteApplicationGuid, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationGuid" },
+	{ FreeRDP_RemoteApplicationIcon, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationIcon" },
+	{ FreeRDP_RemoteApplicationName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationName" },
+	{ FreeRDP_RemoteApplicationProgram, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationProgram" },
+	{ FreeRDP_RemoteApplicationWorkingDir, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationWorkingDir" },
+	{ FreeRDP_RemoteAssistancePassStub, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistancePassStub" },
+	{ FreeRDP_RemoteAssistancePassword, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistancePassword" },
+	{ FreeRDP_RemoteAssistanceRCTicket, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistanceRCTicket" },
+	{ FreeRDP_RemoteAssistanceSessionId, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistanceSessionId" },
+	{ FreeRDP_ServerHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ServerHostname" },
+	{ FreeRDP_ServerLicenseCompanyName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ServerLicenseCompanyName" },
+	{ FreeRDP_ServerLicenseProductName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ServerLicenseProductName" },
+	{ FreeRDP_ShellWorkingDirectory, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ShellWorkingDirectory" },
+	{ FreeRDP_SmartcardCertificate, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SmartcardCertificate" },
+	{ FreeRDP_SmartcardPrivateKey, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SmartcardPrivateKey" },
+	{ FreeRDP_SspiModule, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SspiModule" },
+	{ FreeRDP_TargetNetAddress, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TargetNetAddress" },
+	{ FreeRDP_TerminalDescriptor, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TerminalDescriptor" },
+	{ FreeRDP_TlsSecretsFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TlsSecretsFile" },
+	{ FreeRDP_TransportDumpFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TransportDumpFile" },
+	{ FreeRDP_UserSpecifiedServerName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_UserSpecifiedServerName" },
+	{ FreeRDP_Username, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Username" },
+	{ FreeRDP_WinSCardModule, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WinSCardModule" },
+	{ FreeRDP_WindowTitle, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WindowTitle" },
+	{ FreeRDP_WmClass, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WmClass" },
+	{ FreeRDP_BitmapCacheV2CellInfo, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_BitmapCacheV2CellInfo" },
+	{ FreeRDP_ChannelDefArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ChannelDefArray" },
+	{ FreeRDP_ClientAutoReconnectCookie, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ClientAutoReconnectCookie" },
+	{ FreeRDP_ClientRandom, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ClientRandom" },
+	{ FreeRDP_ClientTimeZone, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ClientTimeZone" },
+	{ FreeRDP_DeviceArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_DeviceArray" },
+	{ FreeRDP_DynamicChannelArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_DynamicChannelArray" },
+	{ FreeRDP_FragCache, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_FragCache" },
+	{ FreeRDP_GlyphCache, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_GlyphCache" },
+	{ FreeRDP_LoadBalanceInfo, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_LoadBalanceInfo" },
+	{ FreeRDP_MonitorDefArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_MonitorDefArray" },
+	{ FreeRDP_MonitorIds, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_MonitorIds" },
+	{ FreeRDP_OrderSupport, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_OrderSupport" },
+	{ FreeRDP_Password51, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_Password51" },
+	{ FreeRDP_RdpServerCertificate, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RdpServerCertificate" },
+	{ FreeRDP_RdpServerRsaKey, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RdpServerRsaKey" },
+	{ FreeRDP_ReceivedCapabilities, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ReceivedCapabilities" },
+	{ FreeRDP_ReceivedCapabilityData, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ReceivedCapabilityData" },
+	{ FreeRDP_ReceivedCapabilityDataSizes, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ReceivedCapabilityDataSizes" },
+	{ FreeRDP_RedirectionGuid, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionGuid" },
+	{ FreeRDP_RedirectionPassword, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionPassword" },
+	{ FreeRDP_RedirectionTargetCertificate, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_RedirectionTargetCertificate" },
+	{ FreeRDP_RedirectionTsvUrl, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionTsvUrl" },
+	{ FreeRDP_ServerAutoReconnectCookie, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ServerAutoReconnectCookie" },
+	{ FreeRDP_ServerCertificate, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ServerCertificate" },
+	{ FreeRDP_ServerLicenseProductIssuers, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ServerLicenseProductIssuers" },
+	{ FreeRDP_ServerRandom, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ServerRandom" },
+	{ FreeRDP_StaticChannelArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_StaticChannelArray" },
+	{ FreeRDP_TargetNetAddresses, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_TargetNetAddresses" },
+	{ FreeRDP_TargetNetPorts, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_TargetNetPorts" },
+	{ FreeRDP_instance, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_instance" },
+};
+
+#endif

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/security.c

@@ -0,0 +1,1002 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Security
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2014 Norbert Federa <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "settings.h"
+#include "security.h"
+
+#include <freerdp/log.h>
+#include <winpr/crypto.h>
+
+#define TAG FREERDP_TAG("core")
+
+static const BYTE A[] = { 'A' };
+static const BYTE BB[] = { 'B', 'B' };
+static const BYTE CCC[] = { 'C', 'C', 'C' };
+
+/* 0x36 repeated 40 times */
+static const BYTE pad1[40] = { "\x36\x36\x36\x36\x36\x36\x36\x36"
+	                           "\x36\x36\x36\x36\x36\x36\x36\x36"
+	                           "\x36\x36\x36\x36\x36\x36\x36\x36"
+	                           "\x36\x36\x36\x36\x36\x36\x36\x36"
+	                           "\x36\x36\x36\x36\x36\x36\x36\x36" };
+
+/* 0x5C repeated 48 times */
+static const BYTE pad2[48] = { "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C"
+	                           "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C"
+	                           "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C"
+	                           "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C"
+	                           "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C"
+	                           "\x5C\x5C\x5C\x5C\x5C\x5C\x5C\x5C" };
+
+static const BYTE fips_reverse_table[256] = {
+	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
+};
+
+static const BYTE fips_oddparity_table[256] = {
+	0x01, 0x01, 0x02, 0x02, 0x04, 0x04, 0x07, 0x07, 0x08, 0x08, 0x0b, 0x0b, 0x0d, 0x0d, 0x0e, 0x0e,
+	0x10, 0x10, 0x13, 0x13, 0x15, 0x15, 0x16, 0x16, 0x19, 0x19, 0x1a, 0x1a, 0x1c, 0x1c, 0x1f, 0x1f,
+	0x20, 0x20, 0x23, 0x23, 0x25, 0x25, 0x26, 0x26, 0x29, 0x29, 0x2a, 0x2a, 0x2c, 0x2c, 0x2f, 0x2f,
+	0x31, 0x31, 0x32, 0x32, 0x34, 0x34, 0x37, 0x37, 0x38, 0x38, 0x3b, 0x3b, 0x3d, 0x3d, 0x3e, 0x3e,
+	0x40, 0x40, 0x43, 0x43, 0x45, 0x45, 0x46, 0x46, 0x49, 0x49, 0x4a, 0x4a, 0x4c, 0x4c, 0x4f, 0x4f,
+	0x51, 0x51, 0x52, 0x52, 0x54, 0x54, 0x57, 0x57, 0x58, 0x58, 0x5b, 0x5b, 0x5d, 0x5d, 0x5e, 0x5e,
+	0x61, 0x61, 0x62, 0x62, 0x64, 0x64, 0x67, 0x67, 0x68, 0x68, 0x6b, 0x6b, 0x6d, 0x6d, 0x6e, 0x6e,
+	0x70, 0x70, 0x73, 0x73, 0x75, 0x75, 0x76, 0x76, 0x79, 0x79, 0x7a, 0x7a, 0x7c, 0x7c, 0x7f, 0x7f,
+	0x80, 0x80, 0x83, 0x83, 0x85, 0x85, 0x86, 0x86, 0x89, 0x89, 0x8a, 0x8a, 0x8c, 0x8c, 0x8f, 0x8f,
+	0x91, 0x91, 0x92, 0x92, 0x94, 0x94, 0x97, 0x97, 0x98, 0x98, 0x9b, 0x9b, 0x9d, 0x9d, 0x9e, 0x9e,
+	0xa1, 0xa1, 0xa2, 0xa2, 0xa4, 0xa4, 0xa7, 0xa7, 0xa8, 0xa8, 0xab, 0xab, 0xad, 0xad, 0xae, 0xae,
+	0xb0, 0xb0, 0xb3, 0xb3, 0xb5, 0xb5, 0xb6, 0xb6, 0xb9, 0xb9, 0xba, 0xba, 0xbc, 0xbc, 0xbf, 0xbf,
+	0xc1, 0xc1, 0xc2, 0xc2, 0xc4, 0xc4, 0xc7, 0xc7, 0xc8, 0xc8, 0xcb, 0xcb, 0xcd, 0xcd, 0xce, 0xce,
+	0xd0, 0xd0, 0xd3, 0xd3, 0xd5, 0xd5, 0xd6, 0xd6, 0xd9, 0xd9, 0xda, 0xda, 0xdc, 0xdc, 0xdf, 0xdf,
+	0xe0, 0xe0, 0xe3, 0xe3, 0xe5, 0xe5, 0xe6, 0xe6, 0xe9, 0xe9, 0xea, 0xea, 0xec, 0xec, 0xef, 0xef,
+	0xf1, 0xf1, 0xf2, 0xf2, 0xf4, 0xf4, 0xf7, 0xf7, 0xf8, 0xf8, 0xfb, 0xfb, 0xfd, 0xfd, 0xfe, 0xfe
+};
+
+static BOOL security_salted_hash(const BYTE* salt, size_t salt_len, const BYTE* input,
+                                 size_t length, const BYTE* salt1, size_t salt1_len,
+                                 const BYTE* salt2, size_t salt2_len, BYTE* output, size_t out_len)
+{
+	WINPR_DIGEST_CTX* sha1 = NULL;
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BYTE sha1_digest[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BOOL result = FALSE;
+
+	/* SaltedHash(Salt, Input, Salt1, Salt2) = MD5(S + SHA1(Input + Salt + Salt1 + Salt2)) */
+	WINPR_ASSERT(out_len >= WINPR_MD5_DIGEST_LENGTH);
+
+	/* SHA1_Digest = SHA1(Input + Salt + Salt1 + Salt2) */
+	if (!(sha1 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, input, length)) /* Input */
+		goto out;
+
+	WINPR_ASSERT(salt_len == 48);
+	if (!winpr_Digest_Update(sha1, salt, salt_len)) /* Salt (48 bytes) */
+		goto out;
+
+	WINPR_ASSERT(salt1_len == 32);
+	if (!winpr_Digest_Update(sha1, salt1, salt1_len)) /* Salt1 (32 bytes) */
+		goto out;
+
+	WINPR_ASSERT(salt2_len == 32);
+	if (!winpr_Digest_Update(sha1, salt2, salt2_len)) /* Salt2 (32 bytes) */
+		goto out;
+
+	if (!winpr_Digest_Final(sha1, sha1_digest, sizeof(sha1_digest)))
+		goto out;
+
+	/* SaltedHash(Salt, Input, Salt1, Salt2) = MD5(S + SHA1_Digest) */
+	if (!(md5 = winpr_Digest_New()))
+		goto out;
+
+	/* Allow FIPS override for use of MD5 here, this is used for creating hashes of the
+	 * premaster_secret and master_secret */
+	/* used for RDP licensing as described in MS-RDPELE. This is for RDP licensing packets */
+	/* which will already be encrypted under FIPS, so the use of MD5 here is not for sensitive data
+	 * protection. */
+	if (!winpr_Digest_Init_Allow_FIPS(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, salt, 48)) /* Salt (48 bytes) */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, sha1_digest, sizeof(sha1_digest))) /* SHA1_Digest */
+		goto out;
+
+	if (!winpr_Digest_Final(md5, output, out_len))
+		goto out;
+
+	result = TRUE;
+out:
+	winpr_Digest_Free(sha1);
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+static BOOL security_premaster_hash(const BYTE* input, size_t length, const BYTE* premaster_secret,
+                                    size_t pre_len, const BYTE* client_random, size_t client_len,
+                                    const BYTE* server_random, size_t server_len, BYTE* output,
+                                    size_t out_len)
+{
+	/* PremasterHash(Input) = SaltedHash(PremasterSecret, Input, ClientRandom, ServerRandom) */
+	return security_salted_hash(premaster_secret, pre_len, input, length, client_random, client_len,
+	                            server_random, server_len, output, out_len);
+}
+
+BOOL security_master_secret(const BYTE* premaster_secret, size_t pre_len, const BYTE* client_random,
+                            size_t client_len, const BYTE* server_random, size_t server_len,
+                            BYTE* output, size_t out_len)
+{
+	/* MasterSecret = PremasterHash('A') + PremasterHash('BB') + PremasterHash('CCC') */
+	WINPR_ASSERT(out_len >= 32);
+	return security_premaster_hash(A, sizeof(A), premaster_secret, pre_len, client_random,
+	                               client_len, server_random, server_len, &output[0], out_len) &&
+	       security_premaster_hash(BB, sizeof(BB), premaster_secret, pre_len, client_random,
+	                               client_len, server_random, server_len, &output[16],
+	                               out_len - 16) &&
+	       security_premaster_hash(CCC, sizeof(CCC), premaster_secret, pre_len, client_random,
+	                               client_len, server_random, server_len, &output[32],
+	                               out_len - 32);
+}
+
+static BOOL security_master_hash(const BYTE* input, size_t length, const BYTE* master_secret,
+                                 size_t master_len, const BYTE* client_random, size_t client_len,
+                                 const BYTE* server_random, size_t server_len, BYTE* output,
+                                 size_t out_len)
+{
+	/* MasterHash(Input) = SaltedHash(MasterSecret, Input, ServerRandom, ClientRandom) */
+	return security_salted_hash(master_secret, master_len, input, length, server_random, server_len,
+	                            client_random, client_len, output, out_len);
+}
+
+BOOL security_session_key_blob(const BYTE* master_secret, size_t master_len,
+                               const BYTE* client_random, size_t client_len,
+                               const BYTE* server_random, size_t server_len, BYTE* output,
+                               size_t out_len)
+{
+	/* MasterHash = MasterHash('A') + MasterHash('BB') + MasterHash('CCC') */
+	WINPR_ASSERT(out_len >= 32);
+	return security_master_hash(A, sizeof(A), master_secret, master_len, client_random, client_len,
+	                            server_random, server_len, &output[0], 16) &&
+	       security_master_hash(BB, sizeof(BB), master_secret, master_len, client_random,
+	                            client_len, server_random, server_len, &output[16], 16) &&
+	       security_master_hash(CCC, sizeof(CCC), master_secret, master_len, client_random,
+	                            client_len, server_random, server_len, &output[32], out_len - 32);
+}
+
+void security_mac_salt_key(const BYTE* session_key_blob, size_t session_len,
+                           const BYTE* client_random, size_t client_len, const BYTE* server_random,
+                           size_t server_len, BYTE* output, size_t out_len)
+{
+	/* MacSaltKey = First128Bits(SessionKeyBlob) */
+	WINPR_ASSERT(out_len >= 16);
+	WINPR_ASSERT(session_len >= 16);
+	WINPR_UNUSED(client_random);
+	WINPR_UNUSED(client_len);
+	WINPR_UNUSED(server_random);
+	WINPR_UNUSED(server_len);
+	memcpy(output, session_key_blob, 16);
+}
+
+static BOOL security_md5_16_32_32(const BYTE* in0, const BYTE* in1, const BYTE* in2, BYTE* output,
+                                  size_t out_len)
+{
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(WINPR_MD5_DIGEST_LENGTH <= out_len);
+
+	if (!(md5 = winpr_Digest_New()))
+		return FALSE;
+
+	if (!winpr_Digest_Init(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, in0, 16))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, in1, 32))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, in2, 32))
+		goto out;
+
+	if (!winpr_Digest_Final(md5, output, out_len))
+		goto out;
+
+	result = TRUE;
+out:
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+static BOOL security_md5_16_32_32_Allow_FIPS(const BYTE* in0, const BYTE* in1, const BYTE* in2,
+                                             BYTE* output, size_t out_len)
+{
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(out_len >= WINPR_MD5_DIGEST_LENGTH);
+
+	if (!(md5 = winpr_Digest_New()))
+		return FALSE;
+	if (!winpr_Digest_Init_Allow_FIPS(md5, WINPR_MD_MD5))
+		goto out;
+	if (!winpr_Digest_Update(md5, in0, 16))
+		goto out;
+	if (!winpr_Digest_Update(md5, in1, 32))
+		goto out;
+	if (!winpr_Digest_Update(md5, in2, 32))
+		goto out;
+	if (!winpr_Digest_Final(md5, output, out_len))
+		goto out;
+
+	result = TRUE;
+out:
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+BOOL security_licensing_encryption_key(const BYTE* session_key_blob, size_t session_len,
+                                       const BYTE* client_random, size_t client_len,
+                                       const BYTE* server_random, size_t server_len, BYTE* output,
+                                       size_t out_len)
+{
+	if (session_len < 16)
+		return FALSE;
+	if (client_len < 32)
+		return FALSE;
+	if (server_len < 32)
+		return FALSE;
+	/* LicensingEncryptionKey = MD5(Second128Bits(SessionKeyBlob) + ClientRandom + ServerRandom))
+	 * Allow FIPS use of MD5 here, this is just used for creating the licensing encryption key as
+	 * described in MS-RDPELE. This is for RDP licensing packets which will already be encrypted
+	 * under FIPS, so the use of MD5 here is not for sensitive data protection. */
+	return security_md5_16_32_32_Allow_FIPS(&session_key_blob[16], client_random, server_random,
+	                                        output, out_len);
+}
+
+static void security_UINT32_le(BYTE* output, size_t out_len, UINT32 value)
+{
+	WINPR_ASSERT(output);
+	WINPR_ASSERT(out_len >= 4);
+	output[0] = (value)&0xFF;
+	output[1] = (value >> 8) & 0xFF;
+	output[2] = (value >> 16) & 0xFF;
+	output[3] = (value >> 24) & 0xFF;
+}
+
+BOOL security_mac_data(const BYTE* mac_salt_key, size_t mac_salt_key_length, const BYTE* data,
+                       size_t length, BYTE* output, size_t output_length)
+{
+	WINPR_DIGEST_CTX* sha1 = NULL;
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BYTE length_le[4] = { 0 };
+	BYTE sha1_digest[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(length <= UINT32_MAX);
+	WINPR_ASSERT(mac_salt_key_length == WINPR_MD5_DIGEST_LENGTH);
+	WINPR_ASSERT(output_length == WINPR_MD5_DIGEST_LENGTH);
+
+	/* MacData = MD5(MacSaltKey + pad2 + SHA1(MacSaltKey + pad1 + length + data)) */
+	security_UINT32_le(length_le, sizeof(length_le),
+	                   (UINT32)length); /* length must be little-endian */
+
+	/* SHA1_Digest = SHA1(MacSaltKey + pad1 + length + data) */
+	if (!(sha1 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, mac_salt_key, mac_salt_key_length)) /* MacSaltKey */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, pad1, sizeof(pad1))) /* pad1 */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, length_le, sizeof(length_le))) /* length */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, data, length)) /* data */
+		goto out;
+
+	if (!winpr_Digest_Final(sha1, sha1_digest, sizeof(sha1_digest)))
+		goto out;
+
+	/* MacData = MD5(MacSaltKey + pad2 + SHA1_Digest) */
+	if (!(md5 = winpr_Digest_New()))
+		goto out;
+
+	/* Allow FIPS override for use of MD5 here, this is only used for creating the MACData field of
+	 * the */
+	/* Client Platform Challenge Response packet (from MS-RDPELE section 2.2.2.5). This is for RDP
+	 * licensing packets */
+	/* which will already be encrypted under FIPS, so the use of MD5 here is not for sensitive data
+	 * protection. */
+	if (!winpr_Digest_Init_Allow_FIPS(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, mac_salt_key, 16)) /* MacSaltKey */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, pad2, sizeof(pad2))) /* pad2 */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, sha1_digest, sizeof(sha1_digest))) /* SHA1_Digest */
+		goto out;
+
+	if (!winpr_Digest_Final(md5, output, output_length))
+		goto out;
+
+	result = TRUE;
+out:
+	if (!result)
+		WLog_ERR(TAG, "failed to create security mac");
+	winpr_Digest_Free(sha1);
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+BOOL security_mac_signature(rdpRdp* rdp, const BYTE* data, UINT32 length, BYTE* output,
+                            size_t out_len)
+{
+	WINPR_DIGEST_CTX* sha1 = NULL;
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BYTE length_le[4] = { 0 };
+	BYTE md5_digest[WINPR_MD5_DIGEST_LENGTH] = { 0 };
+	BYTE sha1_digest[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(data || (length == 0));
+	WINPR_ASSERT(output);
+	WINPR_ASSERT(out_len >= 8);
+
+	security_UINT32_le(length_le, sizeof(length_le), length); /* length must be little-endian */
+
+	/* SHA1_Digest = SHA1(MACKeyN + pad1 + length + data) */
+	if (!(sha1 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, rdp->sign_key, rdp->rc4_key_len)) /* MacKeyN */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, pad1, sizeof(pad1))) /* pad1 */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, length_le, sizeof(length_le))) /* length */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, data, length)) /* data */
+		goto out;
+
+	if (!winpr_Digest_Final(sha1, sha1_digest, sizeof(sha1_digest)))
+		goto out;
+
+	/* MACSignature = First64Bits(MD5(MACKeyN + pad2 + SHA1_Digest)) */
+	if (!(md5 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, rdp->sign_key, rdp->rc4_key_len)) /* MacKeyN */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, pad2, sizeof(pad2))) /* pad2 */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, sha1_digest, sizeof(sha1_digest))) /* SHA1_Digest */
+		goto out;
+
+	if (!winpr_Digest_Final(md5, md5_digest, sizeof(md5_digest)))
+		goto out;
+
+	memcpy(output, md5_digest, 8);
+	result = TRUE;
+out:
+	if (!result)
+		WLog_WARN(TAG, "security mac generation failed");
+	winpr_Digest_Free(sha1);
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+BOOL security_salted_mac_signature(rdpRdp* rdp, const BYTE* data, UINT32 length, BOOL encryption,
+                                   BYTE* output, size_t out_len)
+{
+	WINPR_DIGEST_CTX* sha1 = NULL;
+	WINPR_DIGEST_CTX* md5 = NULL;
+	BYTE length_le[4] = { 0 };
+	BYTE use_count_le[4] = { 0 };
+	BYTE md5_digest[WINPR_MD5_DIGEST_LENGTH] = { 0 };
+	BYTE sha1_digest[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(data || (length == 0));
+	WINPR_ASSERT(output);
+	WINPR_ASSERT(out_len >= 8);
+
+	security_UINT32_le(length_le, sizeof(length_le), length); /* length must be little-endian */
+
+	if (encryption)
+	{
+		security_UINT32_le(use_count_le, sizeof(use_count_le), rdp->encrypt_checksum_use_count);
+	}
+	else
+	{
+		/*
+		 * We calculate checksum on plain text, so we must have already
+		 * decrypt it, which means decrypt_checksum_use_count is off by one.
+		 */
+		security_UINT32_le(use_count_le, sizeof(use_count_le),
+		                   rdp->decrypt_checksum_use_count - 1u);
+	}
+
+	/* SHA1_Digest = SHA1(MACKeyN + pad1 + length + data) */
+	if (!(sha1 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, rdp->sign_key, rdp->rc4_key_len)) /* MacKeyN */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, pad1, sizeof(pad1))) /* pad1 */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, length_le, sizeof(length_le))) /* length */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, data, length)) /* data */
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, use_count_le, sizeof(use_count_le))) /* encryptionCount */
+		goto out;
+
+	if (!winpr_Digest_Final(sha1, sha1_digest, sizeof(sha1_digest)))
+		goto out;
+
+	/* MACSignature = First64Bits(MD5(MACKeyN + pad2 + SHA1_Digest)) */
+	if (!(md5 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, rdp->sign_key, rdp->rc4_key_len)) /* MacKeyN */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, pad2, sizeof(pad2))) /* pad2 */
+		goto out;
+
+	if (!winpr_Digest_Update(md5, sha1_digest, sizeof(sha1_digest))) /* SHA1_Digest */
+		goto out;
+
+	if (!winpr_Digest_Final(md5, md5_digest, sizeof(md5_digest)))
+		goto out;
+
+	memcpy(output, md5_digest, 8);
+	result = TRUE;
+out:
+	if (!result)
+		WLog_WARN(TAG, "security mac signature generation failed");
+
+	winpr_Digest_Free(sha1);
+	winpr_Digest_Free(md5);
+	return result;
+}
+
+static BOOL security_A(const BYTE* master_secret, size_t master_len, const BYTE* client_random,
+                       size_t client_len, const BYTE* server_random, size_t server_len,
+                       BYTE* output, size_t out_len)
+{
+	WINPR_ASSERT(out_len >= 32);
+
+	return security_premaster_hash(A, sizeof(A), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[0], 16) &&
+	       security_premaster_hash(BB, sizeof(BB), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[16], 16) &&
+	       security_premaster_hash(CCC, sizeof(CCC), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[32],
+	                               out_len - 32);
+}
+
+static BOOL security_X(const BYTE* master_secret, size_t master_len, const BYTE* client_random,
+                       size_t client_len, const BYTE* server_random, size_t server_len,
+                       BYTE* output, size_t out_len)
+{
+	const BYTE X[] = { 'X' };
+	const BYTE YY[] = { 'Y', 'Y' };
+	const BYTE ZZZ[] = { 'Z', 'Z', 'Z' };
+
+	WINPR_ASSERT(out_len >= 32);
+
+	return security_premaster_hash(X, sizeof(X), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[0], 16) &&
+	       security_premaster_hash(YY, sizeof(YY), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[16], 16) &&
+	       security_premaster_hash(ZZZ, sizeof(ZZZ), master_secret, master_len, client_random,
+	                               client_len, server_random, server_len, &output[32],
+	                               out_len - 32);
+}
+
+static void fips_expand_key_bits(const BYTE* in, size_t in_len, BYTE* out, size_t out_len)
+{
+	BYTE buf[21] = { 0 };
+
+	WINPR_ASSERT(in);
+	WINPR_ASSERT(in_len >= sizeof(buf));
+
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(out_len >= 24);
+
+	/* reverse every byte in the key */
+	for (size_t i = 0; i < sizeof(buf); i++)
+		buf[i] = fips_reverse_table[in[i]];
+
+	/* insert a zero-bit after every 7th bit */
+	size_t b = 0;
+	for (size_t i = 0; i < 24; i++, b += 7)
+	{
+		const size_t p = b / 8;
+		const size_t r = b % 8;
+
+		WINPR_ASSERT(p < sizeof(buf));
+		if (r <= 1)
+		{
+			out[i] = (buf[p] << r) & 0xfe;
+		}
+		else
+		{
+			WINPR_ASSERT(p + 1 < sizeof(buf));
+			/* c is accumulator */
+			BYTE c = (BYTE)(buf[p] << r) & 0xFF;
+			c |= buf[p + 1] >> (8 - r);
+			out[i] = c & 0xfe;
+		}
+	}
+
+	/* reverse every byte */
+	/* alter lsb so the byte has odd parity */
+	for (size_t i = 0; i < 24; i++)
+		out[i] = fips_oddparity_table[fips_reverse_table[out[i]]];
+}
+
+BOOL security_establish_keys(rdpRdp* rdp)
+{
+	BYTE pre_master_secret[48] = { 0 };
+	BYTE master_secret[48] = { 0 };
+	BYTE session_key_blob[48] = { 0 };
+	BYTE salt[] = { 0xD1, 0x26, 0x9E }; /* 40 bits: 3 bytes, 56 bits: 1 byte */
+	BOOL status = FALSE;
+
+	WINPR_ASSERT(rdp);
+	const rdpSettings* settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	const BYTE* server_random = freerdp_settings_get_pointer(settings, FreeRDP_ServerRandom);
+	const BYTE* client_random = freerdp_settings_get_pointer(settings, FreeRDP_ClientRandom);
+	WINPR_ASSERT(client_random);
+	WINPR_ASSERT(server_random);
+
+	const UINT32 ClientRandomLength =
+	    freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
+	const UINT32 ServerRandomLength =
+	    freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
+	WINPR_ASSERT(ClientRandomLength == 32);
+	WINPR_ASSERT(ServerRandomLength == 32);
+
+	if (settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
+	{
+		BYTE client_encrypt_key_t[WINPR_SHA1_DIGEST_LENGTH + 1] = { 0 };
+		BYTE client_decrypt_key_t[WINPR_SHA1_DIGEST_LENGTH + 1] = { 0 };
+		WINPR_DIGEST_CTX* sha1 = winpr_Digest_New();
+		if (!sha1)
+			return FALSE;
+
+		if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1) ||
+		    !winpr_Digest_Update(sha1, client_random + 16, 16) ||
+		    !winpr_Digest_Update(sha1, server_random + 16, 16) ||
+		    !winpr_Digest_Final(sha1, client_encrypt_key_t, sizeof(client_encrypt_key_t)))
+		{
+			winpr_Digest_Free(sha1);
+			return FALSE;
+		}
+
+		client_encrypt_key_t[20] = client_encrypt_key_t[0];
+
+		if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1) ||
+		    !winpr_Digest_Update(sha1, client_random, 16) ||
+		    !winpr_Digest_Update(sha1, server_random, 16) ||
+		    !winpr_Digest_Final(sha1, client_decrypt_key_t, sizeof(client_decrypt_key_t)))
+		{
+			winpr_Digest_Free(sha1);
+			return FALSE;
+		}
+
+		client_decrypt_key_t[20] = client_decrypt_key_t[0];
+
+		if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1) ||
+		    !winpr_Digest_Update(sha1, client_decrypt_key_t, WINPR_SHA1_DIGEST_LENGTH) ||
+		    !winpr_Digest_Update(sha1, client_encrypt_key_t, WINPR_SHA1_DIGEST_LENGTH) ||
+		    !winpr_Digest_Final(sha1, rdp->fips_sign_key, WINPR_SHA1_DIGEST_LENGTH))
+		{
+			winpr_Digest_Free(sha1);
+			return FALSE;
+		}
+
+		winpr_Digest_Free(sha1);
+
+		if (settings->ServerMode)
+		{
+			fips_expand_key_bits(client_encrypt_key_t, sizeof(client_encrypt_key_t),
+			                     rdp->fips_decrypt_key, sizeof(rdp->fips_decrypt_key));
+			fips_expand_key_bits(client_decrypt_key_t, sizeof(client_decrypt_key_t),
+			                     rdp->fips_encrypt_key, sizeof(rdp->fips_encrypt_key));
+		}
+		else
+		{
+			fips_expand_key_bits(client_encrypt_key_t, sizeof(client_encrypt_key_t),
+			                     rdp->fips_encrypt_key, sizeof(rdp->fips_encrypt_key));
+			fips_expand_key_bits(client_decrypt_key_t, sizeof(client_decrypt_key_t),
+			                     rdp->fips_decrypt_key, sizeof(rdp->fips_decrypt_key));
+		}
+	}
+
+	memcpy(pre_master_secret, client_random, 24);
+	memcpy(pre_master_secret + 24, server_random, 24);
+
+	if (!security_A(pre_master_secret, sizeof(pre_master_secret), client_random, ClientRandomLength,
+	                server_random, ServerRandomLength, master_secret, sizeof(master_secret)) ||
+	    !security_X(master_secret, sizeof(master_secret), client_random, ClientRandomLength,
+	                server_random, ServerRandomLength, session_key_blob, sizeof(session_key_blob)))
+	{
+		return FALSE;
+	}
+
+	memcpy(rdp->sign_key, session_key_blob, 16);
+
+	if (settings->ServerMode)
+	{
+		status = security_md5_16_32_32(&session_key_blob[16], client_random, server_random,
+		                               rdp->encrypt_key, sizeof(rdp->encrypt_key));
+		status &= security_md5_16_32_32(&session_key_blob[32], client_random, server_random,
+		                                rdp->decrypt_key, sizeof(rdp->decrypt_key));
+	}
+	else
+	{
+		/* Allow FIPS use of MD5 here, this is just used for generation of the SessionKeyBlob as
+		 * described in MS-RDPELE. */
+		/* This is for RDP licensing packets which will already be encrypted under FIPS, so the use
+		 * of MD5 here is not */
+		/* for sensitive data protection. */
+		status =
+		    security_md5_16_32_32_Allow_FIPS(&session_key_blob[16], client_random, server_random,
+		                                     rdp->decrypt_key, sizeof(rdp->decrypt_key));
+		status &=
+		    security_md5_16_32_32_Allow_FIPS(&session_key_blob[32], client_random, server_random,
+		                                     rdp->encrypt_key, sizeof(rdp->encrypt_key));
+	}
+
+	if (!status)
+		return FALSE;
+
+	if (settings->EncryptionMethods == ENCRYPTION_METHOD_40BIT)
+	{
+		memcpy(rdp->sign_key, salt, 3);
+		memcpy(rdp->decrypt_key, salt, 3);
+		memcpy(rdp->encrypt_key, salt, 3);
+		rdp->rc4_key_len = 8;
+	}
+	else if (settings->EncryptionMethods == ENCRYPTION_METHOD_56BIT)
+	{
+		memcpy(rdp->sign_key, salt, 1);
+		memcpy(rdp->decrypt_key, salt, 1);
+		memcpy(rdp->encrypt_key, salt, 1);
+		rdp->rc4_key_len = 8;
+	}
+	else if (settings->EncryptionMethods == ENCRYPTION_METHOD_128BIT)
+	{
+		rdp->rc4_key_len = 16;
+	}
+
+	if (!security_lock(rdp))
+		return FALSE;
+	memcpy(rdp->decrypt_update_key, rdp->decrypt_key, 16);
+	memcpy(rdp->encrypt_update_key, rdp->encrypt_key, 16);
+	rdp->decrypt_use_count = 0;
+	rdp->decrypt_checksum_use_count = 0;
+	rdp->encrypt_use_count = 0;
+	rdp->encrypt_checksum_use_count = 0;
+
+	return security_unlock(rdp);
+}
+
+static BOOL security_key_update(BYTE* key, BYTE* update_key, size_t key_len, rdpRdp* rdp)
+{
+	BYTE sha1h[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	WINPR_DIGEST_CTX* sha1 = NULL;
+	WINPR_DIGEST_CTX* md5 = NULL;
+	WINPR_RC4_CTX* rc4 = NULL;
+	BYTE salt[] = { 0xD1, 0x26, 0x9E }; /* 40 bits: 3 bytes, 56 bits: 1 byte */
+	BOOL result = FALSE;
+	WLog_DBG(TAG, "updating RDP key");
+
+	if (!(sha1 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, update_key, key_len))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, pad1, sizeof(pad1)))
+		goto out;
+
+	if (!winpr_Digest_Update(sha1, key, key_len))
+		goto out;
+
+	if (!winpr_Digest_Final(sha1, sha1h, sizeof(sha1h)))
+		goto out;
+
+	if (!(md5 = winpr_Digest_New()))
+		goto out;
+
+	if (!winpr_Digest_Init(md5, WINPR_MD_MD5))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, update_key, key_len))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, pad2, sizeof(pad2)))
+		goto out;
+
+	if (!winpr_Digest_Update(md5, sha1h, sizeof(sha1h)))
+		goto out;
+
+	if (!winpr_Digest_Final(md5, key, WINPR_MD5_DIGEST_LENGTH))
+		goto out;
+
+	if (!(rc4 = winpr_RC4_New(key, key_len)))
+		goto out;
+
+	if (!winpr_RC4_Update(rc4, key_len, key, key))
+		goto out;
+
+	if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_40BIT)
+		memcpy(key, salt, 3);
+	else if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_56BIT)
+		memcpy(key, salt, 1);
+
+	result = TRUE;
+out:
+	winpr_Digest_Free(sha1);
+	winpr_Digest_Free(md5);
+	winpr_RC4_Free(rc4);
+	return result;
+}
+
+BOOL security_encrypt(BYTE* data, size_t length, rdpRdp* rdp)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(rdp);
+	if (!rdp->rc4_encrypt_key)
+	{
+		WLog_ERR(TAG, "rdp->rc4_encrypt_key=%p", rdp->rc4_encrypt_key);
+		goto fail;
+	}
+
+	if (rdp->encrypt_use_count >= 4096)
+	{
+		if (!security_key_update(rdp->encrypt_key, rdp->encrypt_update_key, rdp->rc4_key_len, rdp))
+			goto fail;
+
+		if (!rdp_reset_rc4_encrypt_keys(rdp))
+			goto fail;
+	}
+
+	if (!winpr_RC4_Update(rdp->rc4_encrypt_key, length, data, data))
+		goto fail;
+
+	rdp->encrypt_use_count++;
+	rdp->encrypt_checksum_use_count++;
+	rc = TRUE;
+fail:
+	return rc;
+}
+
+BOOL security_decrypt(BYTE* data, size_t length, rdpRdp* rdp)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(data || (length == 0));
+	WINPR_ASSERT(rdp);
+
+	if (!rdp->rc4_decrypt_key)
+	{
+		WLog_ERR(TAG, "rdp->rc4_decrypt_key=%p", rdp->rc4_decrypt_key);
+		goto fail;
+	}
+
+	if (rdp->decrypt_use_count >= 4096)
+	{
+		if (!security_key_update(rdp->decrypt_key, rdp->decrypt_update_key, rdp->rc4_key_len, rdp))
+			goto fail;
+
+		if (!rdp_reset_rc4_decrypt_keys(rdp))
+			goto fail;
+	}
+
+	if (!winpr_RC4_Update(rdp->rc4_decrypt_key, length, data, data))
+		goto fail;
+
+	rdp->decrypt_use_count += 1;
+	rdp->decrypt_checksum_use_count++;
+	rc = TRUE;
+fail:
+	if (!rc)
+		WLog_WARN(TAG, "Failed to decrypt security");
+	return rc;
+}
+
+BOOL security_hmac_signature(const BYTE* data, size_t length, BYTE* output, size_t out_len,
+                             rdpRdp* rdp)
+{
+	BYTE buf[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BYTE use_count_le[4] = { 0 };
+	WINPR_HMAC_CTX* hmac = NULL;
+	BOOL result = FALSE;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(output);
+	WINPR_ASSERT(out_len >= 8);
+
+	security_UINT32_le(use_count_le, sizeof(use_count_le), rdp->encrypt_use_count);
+
+	if (!(hmac = winpr_HMAC_New()))
+		return FALSE;
+
+	if (!winpr_HMAC_Init(hmac, WINPR_MD_SHA1, rdp->fips_sign_key, WINPR_SHA1_DIGEST_LENGTH))
+		goto out;
+
+	if (!winpr_HMAC_Update(hmac, data, length))
+		goto out;
+
+	if (!winpr_HMAC_Update(hmac, use_count_le, 4))
+		goto out;
+
+	if (!winpr_HMAC_Final(hmac, buf, WINPR_SHA1_DIGEST_LENGTH))
+		goto out;
+
+	memmove(output, buf, 8);
+	result = TRUE;
+out:
+	winpr_HMAC_Free(hmac);
+	return result;
+}
+
+BOOL security_fips_encrypt(BYTE* data, size_t length, rdpRdp* rdp)
+{
+	BOOL rc = FALSE;
+	size_t olen = 0;
+
+	if (!winpr_Cipher_Update(rdp->fips_encrypt, data, length, data, &olen))
+		goto fail;
+
+	rdp->encrypt_use_count++;
+	rc = TRUE;
+fail:
+	return rc;
+}
+
+BOOL security_fips_decrypt(BYTE* data, size_t length, rdpRdp* rdp)
+{
+	size_t olen = 0;
+
+	if (!rdp || !rdp->fips_decrypt)
+	{
+		WLog_ERR(TAG, "rdp=%p, rdp->fips_decrypt=%p", rdp, rdp ? rdp->fips_decrypt : NULL);
+		return FALSE;
+	}
+
+	if (!winpr_Cipher_Update(rdp->fips_decrypt, data, length, data, &olen))
+		return FALSE;
+
+	return TRUE;
+}
+
+BOOL security_fips_check_signature(const BYTE* data, size_t length, const BYTE* sig, size_t sig_len,
+                                   rdpRdp* rdp)
+{
+	BYTE buf[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+	BYTE use_count_le[4] = { 0 };
+	WINPR_HMAC_CTX* hmac = NULL;
+	BOOL result = FALSE;
+
+	security_UINT32_le(use_count_le, sizeof(use_count_le), rdp->decrypt_use_count++);
+
+	if (!(hmac = winpr_HMAC_New()))
+		goto out;
+
+	if (!winpr_HMAC_Init(hmac, WINPR_MD_SHA1, rdp->fips_sign_key, WINPR_SHA1_DIGEST_LENGTH))
+		goto out;
+
+	if (!winpr_HMAC_Update(hmac, data, length))
+		goto out;
+
+	if (!winpr_HMAC_Update(hmac, use_count_le, 4))
+		goto out;
+
+	if (!winpr_HMAC_Final(hmac, buf, WINPR_SHA1_DIGEST_LENGTH))
+		goto out;
+
+	if ((sig_len >= 8) && (memcmp(sig, buf, 8) == 0))
+		result = TRUE;
+
+out:
+	if (!result)
+		WLog_WARN(TAG, "signature check failed");
+	winpr_HMAC_Free(hmac);
+	return result;
+}
+
+BOOL security_lock(rdpRdp* rdp)
+{
+	WINPR_ASSERT(rdp);
+	EnterCriticalSection(&rdp->critical);
+	return TRUE;
+}
+
+BOOL security_unlock(rdpRdp* rdp)
+{
+	WINPR_ASSERT(rdp);
+	LeaveCriticalSection(&rdp->critical);
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/drdynvc.c

@@ -0,0 +1,50 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * drdynvc Utils - Helper functions converting something to string
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/utils/drdynvc.h>
+#include <freerdp/channels/drdynvc.h>
+
+const char* drdynvc_get_packet_type(BYTE cmd)
+{
+	switch (cmd)
+	{
+		case CREATE_REQUEST_PDU:
+			return "CREATE_REQUEST_PDU";
+		case DATA_FIRST_PDU:
+			return "DATA_FIRST_PDU";
+		case DATA_PDU:
+			return "DATA_PDU";
+		case CLOSE_REQUEST_PDU:
+			return "CLOSE_REQUEST_PDU";
+		case CAPABILITY_REQUEST_PDU:
+			return "CAPABILITY_REQUEST_PDU";
+		case DATA_FIRST_COMPRESSED_PDU:
+			return "DATA_FIRST_COMPRESSED_PDU";
+		case DATA_COMPRESSED_PDU:
+			return "DATA_COMPRESSED_PDU";
+		case SOFT_SYNC_REQUEST_PDU:
+			return "SOFT_SYNC_REQUEST_PDU";
+		case SOFT_SYNC_RESPONSE_PDU:
+			return "SOFT_SYNC_RESPONSE_PDU";
+		default:
+			return "UNKNOWN";
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/helpers.c

@@ -0,0 +1,61 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * common helper utilities
+ *
+ * Copyright 2024 Armin Novak <[email protected]>
+ * Copyright 2024 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/utils/helpers.h>
+
+#include <winpr/path.h>
+#include <freerdp/version.h>
+#include <freerdp/build-config.h>
+
+#if defined(WITH_RESOURCE_VERSIONING)
+#define STR(x) #x
+#endif
+
+char* freerdp_GetConfigFilePath(BOOL system, const char* filename)
+{
+	eKnownPathTypes id = system ? KNOWN_PATH_SYSTEM_CONFIG_HOME : KNOWN_PATH_XDG_CONFIG_HOME;
+
+#if defined(FREERDP_USE_VENDOR_PRODUCT_CONFIG_DIR)
+	char* vendor = GetKnownSubPath(id, FREERDP_VENDOR_STRING);
+#else
+	char* vendor = GetKnownPath(id);
+#endif
+	if (!vendor)
+		return NULL;
+
+#if defined(WITH_RESOURCE_VERSIONING)
+	char* verstr = FREERDP_PRODUCT_STRING STR(FREERDP_VERSION_MAJOR);
+#else
+	char* verstr = FREERDP_PRODUCT_STRING;
+#endif
+
+	char* base = GetCombinedPath(vendor, verstr);
+	free(vendor);
+
+	if (!base)
+		return NULL;
+
+	if (!filename)
+		return base;
+
+	char* path = GetCombinedPath(base, filename);
+	free(base);
+	return path;
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/jni/src/c/sqlite3-jni.h

@@ -0,0 +1,2461 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_sqlite_jni_capi_CApi */
+
+#ifndef _Included_org_sqlite_jni_capi_CApi
+#define _Included_org_sqlite_jni_capi_CApi
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef org_sqlite_jni_capi_CApi_SQLITE_ACCESS_EXISTS
+#define org_sqlite_jni_capi_CApi_SQLITE_ACCESS_EXISTS 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ACCESS_READWRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_ACCESS_READWRITE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ACCESS_READ
+#define org_sqlite_jni_capi_CApi_SQLITE_ACCESS_READ 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DENY
+#define org_sqlite_jni_capi_CApi_SQLITE_DENY 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IGNORE
+#define org_sqlite_jni_capi_CApi_SQLITE_IGNORE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_INDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_INDEX 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TABLE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_INDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_INDEX 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_TABLE 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_TRIGGER 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_VIEW
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TEMP_VIEW 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_TRIGGER 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_VIEW
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_VIEW 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DELETE
+#define org_sqlite_jni_capi_CApi_SQLITE_DELETE 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_INDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_INDEX 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TABLE 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_INDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_INDEX 12L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_TABLE 13L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_TRIGGER 14L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_VIEW
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TEMP_VIEW 15L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_TRIGGER 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_VIEW
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_VIEW 17L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INSERT
+#define org_sqlite_jni_capi_CApi_SQLITE_INSERT 18L
+#undef org_sqlite_jni_capi_CApi_SQLITE_PRAGMA
+#define org_sqlite_jni_capi_CApi_SQLITE_PRAGMA 19L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READ
+#define org_sqlite_jni_capi_CApi_SQLITE_READ 20L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SELECT
+#define org_sqlite_jni_capi_CApi_SQLITE_SELECT 21L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRANSACTION
+#define org_sqlite_jni_capi_CApi_SQLITE_TRANSACTION 22L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UPDATE
+#define org_sqlite_jni_capi_CApi_SQLITE_UPDATE 23L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ATTACH
+#define org_sqlite_jni_capi_CApi_SQLITE_ATTACH 24L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DETACH
+#define org_sqlite_jni_capi_CApi_SQLITE_DETACH 25L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ALTER_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_ALTER_TABLE 26L
+#undef org_sqlite_jni_capi_CApi_SQLITE_REINDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_REINDEX 27L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ANALYZE
+#define org_sqlite_jni_capi_CApi_SQLITE_ANALYZE 28L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CREATE_VTABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_CREATE_VTABLE 29L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DROP_VTABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_DROP_VTABLE 30L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FUNCTION
+#define org_sqlite_jni_capi_CApi_SQLITE_FUNCTION 31L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SAVEPOINT
+#define org_sqlite_jni_capi_CApi_SQLITE_SAVEPOINT 32L
+#undef org_sqlite_jni_capi_CApi_SQLITE_RECURSIVE
+#define org_sqlite_jni_capi_CApi_SQLITE_RECURSIVE 33L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATIC
+#define org_sqlite_jni_capi_CApi_SQLITE_STATIC 0LL
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRANSIENT
+#define org_sqlite_jni_capi_CApi_SQLITE_TRANSIENT -1LL
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESETSTART_INVERT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESETSTART_INVERT 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_NOSAVEPOINT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_NOSAVEPOINT 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_INVERT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_INVERT 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_IGNORENOOP
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESETAPPLY_IGNORENOOP 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_DATA
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_DATA 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_NOTFOUND
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_NOTFOUND 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_CONFLICT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_CONFLICT 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_CONSTRAINT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_CONSTRAINT 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_FOREIGN_KEY
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_FOREIGN_KEY 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_OMIT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_OMIT 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_REPLACE
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_REPLACE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_ABORT
+#define org_sqlite_jni_capi_CApi_SQLITE_CHANGESET_ABORT 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SINGLETHREAD
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SINGLETHREAD 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MULTITHREAD
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MULTITHREAD 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SERIALIZED
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SERIALIZED 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MALLOC
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MALLOC 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETMALLOC
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETMALLOC 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SCRATCH
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SCRATCH 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PAGECACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PAGECACHE 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_HEAP
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_HEAP 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MEMSTATUS
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MEMSTATUS 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MUTEX
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MUTEX 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETMUTEX
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETMUTEX 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_LOOKASIDE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_LOOKASIDE 13L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE 14L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETPCACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETPCACHE 15L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_LOG
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_LOG 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_URI
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_URI 17L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE2
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE2 18L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETPCACHE2
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_GETPCACHE2 19L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_COVERING_INDEX_SCAN
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_COVERING_INDEX_SCAN 20L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SQLLOG
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SQLLOG 21L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MMAP_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MMAP_SIZE 22L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_WIN32_HEAPSIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_WIN32_HEAPSIZE 23L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE_HDRSZ
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PCACHE_HDRSZ 24L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PMASZ
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_PMASZ 25L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_STMTJRNL_SPILL
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_STMTJRNL_SPILL 26L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SMALL_MALLOC
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SMALL_MALLOC 27L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SORTERREF_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_SORTERREF_SIZE 28L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MEMDB_MAXSIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONFIG_MEMDB_MAXSIZE 29L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INTEGER
+#define org_sqlite_jni_capi_CApi_SQLITE_INTEGER 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FLOAT
+#define org_sqlite_jni_capi_CApi_SQLITE_FLOAT 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TEXT
+#define org_sqlite_jni_capi_CApi_SQLITE_TEXT 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_BLOB
+#define org_sqlite_jni_capi_CApi_SQLITE_BLOB 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NULL
+#define org_sqlite_jni_capi_CApi_SQLITE_NULL 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_MAINDBNAME
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_MAINDBNAME 1000L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LOOKASIDE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LOOKASIDE 1001L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_FKEY
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_FKEY 1002L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_TRIGGER 1003L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_QPSG
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_QPSG 1007L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_TRIGGER_EQP
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_TRIGGER_EQP 1008L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_RESET_DATABASE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_RESET_DATABASE 1009L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DEFENSIVE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DEFENSIVE 1010L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_WRITABLE_SCHEMA
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LEGACY_ALTER_TABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DQS_DML
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DQS_DML 1013L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DQS_DDL
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_DQS_DDL 1014L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_VIEW
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_ENABLE_VIEW 1015L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LEGACY_FILE_FORMAT
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_TRUSTED_SCHEMA
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_STMT_SCANSTATUS
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_STMT_SCANSTATUS 1018L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_REVERSE_SCANORDER
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_REVERSE_SCANORDER 1019L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_MAX
+#define org_sqlite_jni_capi_CApi_SQLITE_DBCONFIG_MAX 1019L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_USED 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_USED 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_SCHEMA_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_SCHEMA_USED 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_STMT_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_STMT_USED 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_HIT
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_HIT 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_HIT
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_HIT 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_MISS
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_MISS 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_WRITE 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_DEFERRED_FKS
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_DEFERRED_FKS 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_USED_SHARED
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_USED_SHARED 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_SPILL
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_CACHE_SPILL 12L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_MAX
+#define org_sqlite_jni_capi_CApi_SQLITE_DBSTATUS_MAX 12L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UTF8
+#define org_sqlite_jni_capi_CApi_SQLITE_UTF8 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UTF16LE
+#define org_sqlite_jni_capi_CApi_SQLITE_UTF16LE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UTF16BE
+#define org_sqlite_jni_capi_CApi_SQLITE_UTF16BE 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UTF16
+#define org_sqlite_jni_capi_CApi_SQLITE_UTF16 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_UTF16_ALIGNED
+#define org_sqlite_jni_capi_CApi_SQLITE_UTF16_ALIGNED 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LOCKSTATE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LOCKSTATE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_GET_LOCKPROXYFILE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_GET_LOCKPROXYFILE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SET_LOCKPROXYFILE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SET_LOCKPROXYFILE 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LAST_ERRNO
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LAST_ERRNO 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SIZE_HINT
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SIZE_HINT 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CHUNK_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CHUNK_SIZE 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_FILE_POINTER
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_FILE_POINTER 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SYNC_OMITTED
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SYNC_OMITTED 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_AV_RETRY
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_AV_RETRY 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PERSIST_WAL
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PERSIST_WAL 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_OVERWRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_OVERWRITE 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_VFSNAME
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_VFSNAME 12L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_POWERSAFE_OVERWRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_POWERSAFE_OVERWRITE 13L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PRAGMA
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PRAGMA 14L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_BUSYHANDLER
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_BUSYHANDLER 15L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_TEMPFILENAME
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_TEMPFILENAME 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_MMAP_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_MMAP_SIZE 18L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_TRACE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_TRACE 19L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_HAS_MOVED
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_HAS_MOVED 20L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SYNC
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SYNC 21L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_COMMIT_PHASETWO
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_COMMIT_PHASETWO 22L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_SET_HANDLE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_SET_HANDLE 23L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WAL_BLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WAL_BLOCK 24L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_ZIPVFS
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_ZIPVFS 25L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RBU
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RBU 26L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_VFS_POINTER
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_VFS_POINTER 27L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_JOURNAL_POINTER
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_JOURNAL_POINTER 28L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_GET_HANDLE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_WIN32_GET_HANDLE 29L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PDB
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_PDB 30L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_BEGIN_ATOMIC_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LOCK_TIMEOUT
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_LOCK_TIMEOUT 34L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_DATA_VERSION
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_DATA_VERSION 35L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SIZE_LIMIT
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_SIZE_LIMIT 36L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKPT_DONE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKPT_DONE 37L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RESERVE_BYTES
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RESERVE_BYTES 38L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKPT_START
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKPT_START 39L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_EXTERNAL_READER
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_EXTERNAL_READER 40L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKSM_FILE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_CKSM_FILE 41L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RESET_CACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_FCNTL_RESET_CACHE 42L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCK_NONE
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCK_NONE 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCK_SHARED
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCK_SHARED 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCK_RESERVED
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCK_RESERVED 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCK_PENDING
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCK_PENDING 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCK_EXCLUSIVE
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCK_EXCLUSIVE 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC512
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC512 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC1K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC1K 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC2K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC2K 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC4K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC4K 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC8K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC8K 32L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC16K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC16K 64L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC32K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC32K 128L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC64K
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_ATOMIC64K 256L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_SAFE_APPEND
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_SAFE_APPEND 512L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_SEQUENTIAL
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_SEQUENTIAL 1024L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 2048L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_POWERSAFE_OVERWRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_POWERSAFE_OVERWRITE 4096L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_IMMUTABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_IMMUTABLE 8192L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOCAP_BATCH_ATOMIC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOCAP_BATCH_ATOMIC 16384L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_LENGTH
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_LENGTH 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_SQL_LENGTH
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_SQL_LENGTH 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_COLUMN
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_COLUMN 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_EXPR_DEPTH
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_EXPR_DEPTH 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_COMPOUND_SELECT
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_COMPOUND_SELECT 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_VDBE_OP
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_VDBE_OP 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_FUNCTION_ARG
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_FUNCTION_ARG 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_ATTACHED
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_ATTACHED 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_VARIABLE_NUMBER
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_VARIABLE_NUMBER 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_TRIGGER_DEPTH
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_TRIGGER_DEPTH 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LIMIT_WORKER_THREADS
+#define org_sqlite_jni_capi_CApi_SQLITE_LIMIT_WORKER_THREADS 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_READONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_READONLY 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_READWRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_READWRITE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_CREATE
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_CREATE 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_URI
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_URI 64L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_MEMORY
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_MEMORY 128L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_NOMUTEX
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_NOMUTEX 32768L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_FULLMUTEX
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_FULLMUTEX 65536L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_SHAREDCACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_SHAREDCACHE 131072L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_PRIVATECACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_PRIVATECACHE 262144L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_NOFOLLOW
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_NOFOLLOW 16777216L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OPEN_EXRESCODE
+#define org_sqlite_jni_capi_CApi_SQLITE_OPEN_EXRESCODE 33554432L
+#undef org_sqlite_jni_capi_CApi_SQLITE_PREPARE_PERSISTENT
+#define org_sqlite_jni_capi_CApi_SQLITE_PREPARE_PERSISTENT 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_PREPARE_NO_VTAB
+#define org_sqlite_jni_capi_CApi_SQLITE_PREPARE_NO_VTAB 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OK
+#define org_sqlite_jni_capi_CApi_SQLITE_OK 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ERROR
+#define org_sqlite_jni_capi_CApi_SQLITE_ERROR 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INTERNAL
+#define org_sqlite_jni_capi_CApi_SQLITE_INTERNAL 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_PERM
+#define org_sqlite_jni_capi_CApi_SQLITE_PERM 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ABORT
+#define org_sqlite_jni_capi_CApi_SQLITE_ABORT 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_BUSY
+#define org_sqlite_jni_capi_CApi_SQLITE_BUSY 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCKED
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCKED 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOMEM
+#define org_sqlite_jni_capi_CApi_SQLITE_NOMEM 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INTERRUPT
+#define org_sqlite_jni_capi_CApi_SQLITE_INTERRUPT 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR 10L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CORRUPT
+#define org_sqlite_jni_capi_CApi_SQLITE_CORRUPT 11L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOTFOUND
+#define org_sqlite_jni_capi_CApi_SQLITE_NOTFOUND 12L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FULL
+#define org_sqlite_jni_capi_CApi_SQLITE_FULL 13L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN 14L
+#undef org_sqlite_jni_capi_CApi_SQLITE_PROTOCOL
+#define org_sqlite_jni_capi_CApi_SQLITE_PROTOCOL 15L
+#undef org_sqlite_jni_capi_CApi_SQLITE_EMPTY
+#define org_sqlite_jni_capi_CApi_SQLITE_EMPTY 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SCHEMA
+#define org_sqlite_jni_capi_CApi_SQLITE_SCHEMA 17L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TOOBIG
+#define org_sqlite_jni_capi_CApi_SQLITE_TOOBIG 18L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT 19L
+#undef org_sqlite_jni_capi_CApi_SQLITE_MISMATCH
+#define org_sqlite_jni_capi_CApi_SQLITE_MISMATCH 20L
+#undef org_sqlite_jni_capi_CApi_SQLITE_MISUSE
+#define org_sqlite_jni_capi_CApi_SQLITE_MISUSE 21L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOLFS
+#define org_sqlite_jni_capi_CApi_SQLITE_NOLFS 22L
+#undef org_sqlite_jni_capi_CApi_SQLITE_AUTH
+#define org_sqlite_jni_capi_CApi_SQLITE_AUTH 23L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FORMAT
+#define org_sqlite_jni_capi_CApi_SQLITE_FORMAT 24L
+#undef org_sqlite_jni_capi_CApi_SQLITE_RANGE
+#define org_sqlite_jni_capi_CApi_SQLITE_RANGE 25L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOTADB
+#define org_sqlite_jni_capi_CApi_SQLITE_NOTADB 26L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOTICE
+#define org_sqlite_jni_capi_CApi_SQLITE_NOTICE 27L
+#undef org_sqlite_jni_capi_CApi_SQLITE_WARNING
+#define org_sqlite_jni_capi_CApi_SQLITE_WARNING 28L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ROW
+#define org_sqlite_jni_capi_CApi_SQLITE_ROW 100L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DONE
+#define org_sqlite_jni_capi_CApi_SQLITE_DONE 101L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ERROR_MISSING_COLLSEQ
+#define org_sqlite_jni_capi_CApi_SQLITE_ERROR_MISSING_COLLSEQ 257L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ERROR_RETRY
+#define org_sqlite_jni_capi_CApi_SQLITE_ERROR_RETRY 513L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ERROR_SNAPSHOT
+#define org_sqlite_jni_capi_CApi_SQLITE_ERROR_SNAPSHOT 769L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_READ
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_READ 266L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHORT_READ
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHORT_READ 522L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_WRITE 778L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_FSYNC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_FSYNC 1034L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_DIR_FSYNC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_DIR_FSYNC 1290L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_TRUNCATE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_TRUNCATE 1546L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_FSTAT
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_FSTAT 1802L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_UNLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_UNLOCK 2058L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_RDLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_RDLOCK 2314L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_DELETE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_DELETE 2570L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_BLOCKED
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_BLOCKED 2826L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_NOMEM
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_NOMEM 3082L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_ACCESS
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_ACCESS 3338L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_CHECKRESERVEDLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_CHECKRESERVEDLOCK 3594L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_LOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_LOCK 3850L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_CLOSE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_CLOSE 4106L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_DIR_CLOSE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_DIR_CLOSE 4362L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMOPEN
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMOPEN 4618L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMSIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMSIZE 4874L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMLOCK 5130L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMMAP
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SHMMAP 5386L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_SEEK
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_SEEK 5642L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_DELETE_NOENT
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_DELETE_NOENT 5898L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_MMAP
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_MMAP 6154L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_GETTEMPPATH
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_GETTEMPPATH 6410L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_CONVPATH
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_CONVPATH 6666L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_VNODE
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_VNODE 6922L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_AUTH
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_AUTH 7178L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_BEGIN_ATOMIC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_BEGIN_ATOMIC 7434L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_COMMIT_ATOMIC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_COMMIT_ATOMIC 7690L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_ROLLBACK_ATOMIC
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_ROLLBACK_ATOMIC 7946L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_DATA
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_DATA 8202L
+#undef org_sqlite_jni_capi_CApi_SQLITE_IOERR_CORRUPTFS
+#define org_sqlite_jni_capi_CApi_SQLITE_IOERR_CORRUPTFS 8458L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCKED_SHAREDCACHE
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCKED_SHAREDCACHE 262L
+#undef org_sqlite_jni_capi_CApi_SQLITE_LOCKED_VTAB
+#define org_sqlite_jni_capi_CApi_SQLITE_LOCKED_VTAB 518L
+#undef org_sqlite_jni_capi_CApi_SQLITE_BUSY_RECOVERY
+#define org_sqlite_jni_capi_CApi_SQLITE_BUSY_RECOVERY 261L
+#undef org_sqlite_jni_capi_CApi_SQLITE_BUSY_SNAPSHOT
+#define org_sqlite_jni_capi_CApi_SQLITE_BUSY_SNAPSHOT 517L
+#undef org_sqlite_jni_capi_CApi_SQLITE_BUSY_TIMEOUT
+#define org_sqlite_jni_capi_CApi_SQLITE_BUSY_TIMEOUT 773L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_NOTEMPDIR
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_NOTEMPDIR 270L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_ISDIR
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_ISDIR 526L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_FULLPATH
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_FULLPATH 782L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_CONVPATH
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_CONVPATH 1038L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_SYMLINK
+#define org_sqlite_jni_capi_CApi_SQLITE_CANTOPEN_SYMLINK 1550L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_VTAB
+#define org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_VTAB 267L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_SEQUENCE
+#define org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_SEQUENCE 523L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_INDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_CORRUPT_INDEX 779L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_RECOVERY
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_RECOVERY 264L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_CANTLOCK
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_CANTLOCK 520L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_ROLLBACK
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_ROLLBACK 776L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_DBMOVED
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_DBMOVED 1032L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_CANTINIT
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_CANTINIT 1288L
+#undef org_sqlite_jni_capi_CApi_SQLITE_READONLY_DIRECTORY
+#define org_sqlite_jni_capi_CApi_SQLITE_READONLY_DIRECTORY 1544L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ABORT_ROLLBACK
+#define org_sqlite_jni_capi_CApi_SQLITE_ABORT_ROLLBACK 516L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_CHECK
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_CHECK 275L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_COMMITHOOK
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_COMMITHOOK 531L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_FOREIGNKEY
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_FOREIGNKEY 787L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_FUNCTION
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_FUNCTION 1043L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_NOTNULL
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_NOTNULL 1299L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_PRIMARYKEY
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_PRIMARYKEY 1555L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_TRIGGER
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_TRIGGER 1811L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_UNIQUE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_UNIQUE 2067L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_VTAB
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_VTAB 2323L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_ROWID
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_ROWID 2579L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_PINNED
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_PINNED 2835L
+#undef org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_DATATYPE
+#define org_sqlite_jni_capi_CApi_SQLITE_CONSTRAINT_DATATYPE 3091L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOTICE_RECOVER_WAL
+#define org_sqlite_jni_capi_CApi_SQLITE_NOTICE_RECOVER_WAL 283L
+#undef org_sqlite_jni_capi_CApi_SQLITE_NOTICE_RECOVER_ROLLBACK
+#define org_sqlite_jni_capi_CApi_SQLITE_NOTICE_RECOVER_ROLLBACK 539L
+#undef org_sqlite_jni_capi_CApi_SQLITE_WARNING_AUTOINDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_WARNING_AUTOINDEX 284L
+#undef org_sqlite_jni_capi_CApi_SQLITE_AUTH_USER
+#define org_sqlite_jni_capi_CApi_SQLITE_AUTH_USER 279L
+#undef org_sqlite_jni_capi_CApi_SQLITE_OK_LOAD_PERMANENTLY
+#define org_sqlite_jni_capi_CApi_SQLITE_OK_LOAD_PERMANENTLY 256L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SERIALIZE_NOCOPY
+#define org_sqlite_jni_capi_CApi_SQLITE_SERIALIZE_NOCOPY 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_FREEONCLOSE
+#define org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_FREEONCLOSE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_READONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_READONLY 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_RESIZEABLE
+#define org_sqlite_jni_capi_CApi_SQLITE_DESERIALIZE_RESIZEABLE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SESSION_CONFIG_STRMSIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_SESSION_CONFIG_STRMSIZE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SESSION_OBJCONFIG_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_SESSION_OBJCONFIG_SIZE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_MEMORY_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_MEMORY_USED 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_USED
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_USED 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_OVERFLOW
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_OVERFLOW 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_MALLOC_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_MALLOC_SIZE 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_PARSER_STACK
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_PARSER_STACK 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_SIZE
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_PAGECACHE_SIZE 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STATUS_MALLOC_COUNT
+#define org_sqlite_jni_capi_CApi_SQLITE_STATUS_MALLOC_COUNT 9L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FULLSCAN_STEP
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FULLSCAN_STEP 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_SORT
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_SORT 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_AUTOINDEX
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_AUTOINDEX 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_VM_STEP
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_VM_STEP 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_REPREPARE
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_REPREPARE 5L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_RUN
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_RUN 6L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FILTER_MISS
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FILTER_MISS 7L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FILTER_HIT
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_FILTER_HIT 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_MEMUSED
+#define org_sqlite_jni_capi_CApi_SQLITE_STMTSTATUS_MEMUSED 99L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SYNC_NORMAL
+#define org_sqlite_jni_capi_CApi_SQLITE_SYNC_NORMAL 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SYNC_FULL
+#define org_sqlite_jni_capi_CApi_SQLITE_SYNC_FULL 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SYNC_DATAONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_SYNC_DATAONLY 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRACE_STMT
+#define org_sqlite_jni_capi_CApi_SQLITE_TRACE_STMT 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRACE_PROFILE
+#define org_sqlite_jni_capi_CApi_SQLITE_TRACE_PROFILE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRACE_ROW
+#define org_sqlite_jni_capi_CApi_SQLITE_TRACE_ROW 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TRACE_CLOSE
+#define org_sqlite_jni_capi_CApi_SQLITE_TRACE_CLOSE 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TXN_NONE
+#define org_sqlite_jni_capi_CApi_SQLITE_TXN_NONE 0L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TXN_READ
+#define org_sqlite_jni_capi_CApi_SQLITE_TXN_READ 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_TXN_WRITE
+#define org_sqlite_jni_capi_CApi_SQLITE_TXN_WRITE 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DETERMINISTIC
+#define org_sqlite_jni_capi_CApi_SQLITE_DETERMINISTIC 2048L
+#undef org_sqlite_jni_capi_CApi_SQLITE_DIRECTONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_DIRECTONLY 524288L
+#undef org_sqlite_jni_capi_CApi_SQLITE_SUBTYPE
+#define org_sqlite_jni_capi_CApi_SQLITE_SUBTYPE 1048576L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INNOCUOUS
+#define org_sqlite_jni_capi_CApi_SQLITE_INNOCUOUS 2097152L
+#undef org_sqlite_jni_capi_CApi_SQLITE_RESULT_SUBTYPE
+#define org_sqlite_jni_capi_CApi_SQLITE_RESULT_SUBTYPE 16777216L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_SCAN_UNIQUE
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_SCAN_UNIQUE 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_EQ
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_EQ 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GT
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GT 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LE
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LE 8L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LT
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LT 16L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GE
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GE 32L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_MATCH
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_MATCH 64L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LIKE
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LIKE 65L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GLOB
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_GLOB 66L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_REGEXP
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_REGEXP 67L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_NE
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_NE 68L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNOT
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNOT 69L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNOTNULL
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNULL
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_ISNULL 71L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_IS
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_IS 72L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LIMIT
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_LIMIT 73L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_OFFSET
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_OFFSET 74L
+#undef org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_FUNCTION
+#define org_sqlite_jni_capi_CApi_SQLITE_INDEX_CONSTRAINT_FUNCTION 150L
+#undef org_sqlite_jni_capi_CApi_SQLITE_VTAB_CONSTRAINT_SUPPORT
+#define org_sqlite_jni_capi_CApi_SQLITE_VTAB_CONSTRAINT_SUPPORT 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_VTAB_INNOCUOUS
+#define org_sqlite_jni_capi_CApi_SQLITE_VTAB_INNOCUOUS 2L
+#undef org_sqlite_jni_capi_CApi_SQLITE_VTAB_DIRECTONLY
+#define org_sqlite_jni_capi_CApi_SQLITE_VTAB_DIRECTONLY 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_VTAB_USES_ALL_SCHEMAS
+#define org_sqlite_jni_capi_CApi_SQLITE_VTAB_USES_ALL_SCHEMAS 4L
+#undef org_sqlite_jni_capi_CApi_SQLITE_ROLLBACK
+#define org_sqlite_jni_capi_CApi_SQLITE_ROLLBACK 1L
+#undef org_sqlite_jni_capi_CApi_SQLITE_FAIL
+#define org_sqlite_jni_capi_CApi_SQLITE_FAIL 3L
+#undef org_sqlite_jni_capi_CApi_SQLITE_REPLACE
+#define org_sqlite_jni_capi_CApi_SQLITE_REPLACE 5L
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_init
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_java_uncache_thread
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1java_1uncache_1thread
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_jni_supports_nio
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1jni_1supports_1nio
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_jni_db_error
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;ILjava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1jni_1db_1error
+  (JNIEnv *, jclass, jobject, jint, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_aggregate_context
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;Z)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1aggregate_1context
+  (JNIEnv *, jclass, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_auto_extension
+ * Signature: (Lorg/sqlite/jni/capi/AutoExtensionCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1auto_1extension
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_backup_finish
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1backup_1finish
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_backup_init
+ * Signature: (JLjava/lang/String;JLjava/lang/String;)Lorg/sqlite/jni/capi/sqlite3_backup;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1backup_1init
+  (JNIEnv *, jclass, jlong, jstring, jlong, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_backup_pagecount
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1backup_1pagecount
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_backup_remaining
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1backup_1remaining
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_backup_step
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1backup_1step
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_blob
+ * Signature: (JI[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1blob
+  (JNIEnv *, jclass, jlong, jint, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_double
+ * Signature: (JID)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1double
+  (JNIEnv *, jclass, jlong, jint, jdouble);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_int
+ * Signature: (JII)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1int
+  (JNIEnv *, jclass, jlong, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_int64
+ * Signature: (JIJ)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1int64
+  (JNIEnv *, jclass, jlong, jint, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_java_object
+ * Signature: (JILjava/lang/Object;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1java_1object
+  (JNIEnv *, jclass, jlong, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_nio_buffer
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;ILjava/nio/ByteBuffer;II)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1nio_1buffer
+  (JNIEnv *, jclass, jobject, jint, jobject, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_null
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1null
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_parameter_count
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1parameter_1count
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_parameter_index
+ * Signature: (J[B)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1parameter_1index
+  (JNIEnv *, jclass, jlong, jbyteArray);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_parameter_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1parameter_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_text
+ * Signature: (JI[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1text
+  (JNIEnv *, jclass, jlong, jint, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_text16
+ * Signature: (JI[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1text16
+  (JNIEnv *, jclass, jlong, jint, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_value
+ * Signature: (JIJ)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1value
+  (JNIEnv *, jclass, jlong, jint, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_zeroblob
+ * Signature: (JII)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1zeroblob
+  (JNIEnv *, jclass, jlong, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_bind_zeroblob64
+ * Signature: (JIJ)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1bind_1zeroblob64
+  (JNIEnv *, jclass, jlong, jint, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_bytes
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1bytes
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_close
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1close
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_open
+ * Signature: (JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;JILorg/sqlite/jni/capi/OutputPointer/sqlite3_blob;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1open
+  (JNIEnv *, jclass, jlong, jstring, jstring, jstring, jlong, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_read
+ * Signature: (J[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1read
+  (JNIEnv *, jclass, jlong, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_read_nio_buffer
+ * Signature: (JILjava/nio/ByteBuffer;II)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1read_1nio_1buffer
+  (JNIEnv *, jclass, jlong, jint, jobject, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_reopen
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1reopen
+  (JNIEnv *, jclass, jlong, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_write
+ * Signature: (J[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1write
+  (JNIEnv *, jclass, jlong, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_blob_write_nio_buffer
+ * Signature: (JILjava/nio/ByteBuffer;II)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1write_1nio_1buffer
+  (JNIEnv *, jclass, jlong, jint, jobject, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_busy_handler
+ * Signature: (JLorg/sqlite/jni/capi/BusyHandlerCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1busy_1handler
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_busy_timeout
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1busy_1timeout
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_cancel_auto_extension
+ * Signature: (Lorg/sqlite/jni/capi/AutoExtensionCallback;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1cancel_1auto_1extension
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_changes
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1changes
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_changes64
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1changes64
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_clear_bindings
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1clear_1bindings
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_close
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1close
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_close_v2
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1close_1v2
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_blob
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1blob
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_bytes
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1bytes
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_bytes16
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1bytes16
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_count
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1count
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_database_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1database_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_decltype
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1decltype
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_double
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)D
+ */
+JNIEXPORT jdouble JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1double
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_int
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1int
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_int64
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1int64
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_java_object
+ * Signature: (JI)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1java_1object
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_nio_buffer
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)Ljava/nio/ByteBuffer;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1nio_1buffer
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_origin_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1origin_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_table_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1table_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_text
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1text
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_text16
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1text16
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_type
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1type
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_column_value
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;I)Lorg/sqlite/jni/capi/sqlite3_value;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1column_1value
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_collation_needed
+ * Signature: (JLorg/sqlite/jni/capi/CollationNeededCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1collation_1needed
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_commit_hook
+ * Signature: (JLorg/sqlite/jni/capi/CommitHookCallback;)Lorg/sqlite/jni/capi/CommitHookCallback;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1commit_1hook
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_compileoption_get
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1compileoption_1get
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_compileoption_used
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1compileoption_1used
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_complete
+ * Signature: ([B)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1complete
+  (JNIEnv *, jclass, jbyteArray);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_config__enable
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1config_1_1enable
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_config__CONFIG_LOG
+ * Signature: (Lorg/sqlite/jni/capi/ConfigLogCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1config_1_1CONFIG_1LOG
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_config__SQLLOG
+ * Signature: (Lorg/sqlite/jni/capi/ConfigSqlLogCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1config_1_1SQLLOG
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_context_db_handle
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;)Lorg/sqlite/jni/capi/sqlite3;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1context_1db_1handle
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_create_collation
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;ILorg/sqlite/jni/capi/CollationCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1create_1collation
+  (JNIEnv *, jclass, jobject, jstring, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_create_function
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;IILorg/sqlite/jni/capi/SQLFunction;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1create_1function
+  (JNIEnv *, jclass, jobject, jstring, jint, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_data_count
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1data_1count
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_config
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;IILorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1config__Lorg_sqlite_jni_capi_sqlite3_2IILorg_sqlite_jni_capi_OutputPointer_Int32_2
+  (JNIEnv *, jclass, jobject, jint, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_config
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;ILjava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1config__Lorg_sqlite_jni_capi_sqlite3_2ILjava_lang_String_2
+  (JNIEnv *, jclass, jobject, jint, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_name
+ * Signature: (JI)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1name
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_filename
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1filename
+  (JNIEnv *, jclass, jobject, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_handle
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Lorg/sqlite/jni/capi/sqlite3;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1handle
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_readonly
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1readonly
+  (JNIEnv *, jclass, jobject, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_release_memory
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1release_1memory
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_db_status
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;ILorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;Z)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1status
+  (JNIEnv *, jclass, jobject, jint, jobject, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_errcode
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1errcode
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_errmsg
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1errmsg
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_error_offset
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1error_1offset
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_errstr
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1errstr
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_expanded_sql
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1expanded_1sql
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_extended_errcode
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1extended_1errcode
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_extended_result_codes
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Z)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1extended_1result_1codes
+  (JNIEnv *, jclass, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_get_autocommit
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1get_1autocommit
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_get_auxdata
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;I)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1get_1auxdata
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_finalize
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1finalize
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_initialize
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1initialize
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_interrupt
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1interrupt
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_is_interrupted
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1is_1interrupted
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_keyword_check
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1keyword_1check
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_keyword_count
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1keyword_1count
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_keyword_name
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1keyword_1name
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_last_insert_rowid
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1last_1insert_1rowid
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_libversion
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1libversion
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_libversion_number
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1libversion_1number
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_limit
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;II)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1limit
+  (JNIEnv *, jclass, jobject, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_normalized_sql
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1normalized_1sql
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_open
+ * Signature: (Ljava/lang/String;Lorg/sqlite/jni/capi/OutputPointer/sqlite3;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1open
+  (JNIEnv *, jclass, jstring, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_open_v2
+ * Signature: (Ljava/lang/String;Lorg/sqlite/jni/capi/OutputPointer/sqlite3;ILjava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1open_1v2
+  (JNIEnv *, jclass, jstring, jobject, jint, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_prepare
+ * Signature: (J[BILorg/sqlite/jni/capi/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1prepare
+  (JNIEnv *, jclass, jlong, jbyteArray, jint, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_prepare_v2
+ * Signature: (J[BILorg/sqlite/jni/capi/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1prepare_1v2
+  (JNIEnv *, jclass, jlong, jbyteArray, jint, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_prepare_v3
+ * Signature: (J[BIILorg/sqlite/jni/capi/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1prepare_1v3
+  (JNIEnv *, jclass, jlong, jbyteArray, jint, jint, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_blobwrite
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1blobwrite
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_count
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1count
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_depth
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1depth
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_hook
+ * Signature: (JLorg/sqlite/jni/capi/PreupdateHookCallback;)Lorg/sqlite/jni/capi/PreupdateHookCallback;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1hook
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_new
+ * Signature: (JILorg/sqlite/jni/capi/OutputPointer/sqlite3_value;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1new
+  (JNIEnv *, jclass, jlong, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_preupdate_old
+ * Signature: (JILorg/sqlite/jni/capi/OutputPointer/sqlite3_value;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1preupdate_1old
+  (JNIEnv *, jclass, jlong, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_progress_handler
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;ILorg/sqlite/jni/capi/ProgressHandlerCallback;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1progress_1handler
+  (JNIEnv *, jclass, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_randomness
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1randomness
+  (JNIEnv *, jclass, jbyteArray);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_release_memory
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1release_1memory
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_reset
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1reset
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_reset_auto_extension
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1reset_1auto_1extension
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_double
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;D)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1double
+  (JNIEnv *, jclass, jobject, jdouble);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_error
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;[BI)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1error
+  (JNIEnv *, jclass, jobject, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_error_toobig
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1error_1toobig
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_error_nomem
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1error_1nomem
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_error_code
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;I)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1error_1code
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_int
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;I)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1int
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_int64
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;J)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1int64
+  (JNIEnv *, jclass, jobject, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_java_object
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1java_1object
+  (JNIEnv *, jclass, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_nio_buffer
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;Ljava/nio/ByteBuffer;II)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1nio_1buffer
+  (JNIEnv *, jclass, jobject, jobject, jint, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_null
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1null
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_subtype
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;I)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1subtype
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_value
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;Lorg/sqlite/jni/capi/sqlite3_value;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1value
+  (JNIEnv *, jclass, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_zeroblob
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;I)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1zeroblob
+  (JNIEnv *, jclass, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_zeroblob64
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1zeroblob64
+  (JNIEnv *, jclass, jobject, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_blob
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;[BI)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1blob
+  (JNIEnv *, jclass, jobject, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_blob64
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;[BJ)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1blob64
+  (JNIEnv *, jclass, jobject, jbyteArray, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_text
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;[BI)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1text
+  (JNIEnv *, jclass, jobject, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_result_text64
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;[BJI)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1result_1text64
+  (JNIEnv *, jclass, jobject, jbyteArray, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_rollback_hook
+ * Signature: (JLorg/sqlite/jni/capi/RollbackHookCallback;)Lorg/sqlite/jni/capi/RollbackHookCallback;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1rollback_1hook
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_set_authorizer
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Lorg/sqlite/jni/capi/AuthorizerCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1set_1authorizer
+  (JNIEnv *, jclass, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_set_auxdata
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_context;ILjava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1set_1auxdata
+  (JNIEnv *, jclass, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_set_last_insert_rowid
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;J)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1set_1last_1insert_1rowid
+  (JNIEnv *, jclass, jobject, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_shutdown
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1shutdown
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_sleep
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1sleep
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_sourceid
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1sourceid
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_sql
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1sql
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_status
+ * Signature: (ILorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;Z)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1status
+  (JNIEnv *, jclass, jint, jobject, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_status64
+ * Signature: (ILorg/sqlite/jni/capi/OutputPointer/Int64;Lorg/sqlite/jni/capi/OutputPointer/Int64;Z)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1status64
+  (JNIEnv *, jclass, jint, jobject, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_step
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1step
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_stmt_busy
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1stmt_1busy
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_stmt_explain
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1stmt_1explain
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_stmt_isexplain
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1stmt_1isexplain
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_stmt_readonly
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1stmt_1readonly
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_stmt_status
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_stmt;IZ)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1stmt_1status
+  (JNIEnv *, jclass, jobject, jint, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_strglob
+ * Signature: ([B[B)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1strglob
+  (JNIEnv *, jclass, jbyteArray, jbyteArray);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_strlike
+ * Signature: ([B[BI)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1strlike
+  (JNIEnv *, jclass, jbyteArray, jbyteArray, jint);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_system_errno
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1system_1errno
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_table_column_metadata
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/sqlite/jni/capi/OutputPointer/String;Lorg/sqlite/jni/capi/OutputPointer/String;Lorg/sqlite/jni/capi/OutputPointer/Bool;Lorg/sqlite/jni/capi/OutputPointer/Bool;Lorg/sqlite/jni/capi/OutputPointer/Bool;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1table_1column_1metadata
+  (JNIEnv *, jclass, jobject, jstring, jstring, jstring, jobject, jobject, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_threadsafe
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1threadsafe
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_total_changes
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1total_1changes
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_total_changes64
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1total_1changes64
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_trace_v2
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;ILorg/sqlite/jni/capi/TraceV2Callback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1trace_1v2
+  (JNIEnv *, jclass, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_txn_state
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;Ljava/lang/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1txn_1state
+  (JNIEnv *, jclass, jobject, jstring);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_update_hook
+ * Signature: (JLorg/sqlite/jni/capi/UpdateHookCallback;)Lorg/sqlite/jni/capi/UpdateHookCallback;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1update_1hook
+  (JNIEnv *, jclass, jlong, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_blob
+ * Signature: (J)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1blob
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_bytes
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1bytes
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_bytes16
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1bytes16
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_double
+ * Signature: (J)D
+ */
+JNIEXPORT jdouble JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1double
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_dup
+ * Signature: (J)Lorg/sqlite/jni/capi/sqlite3_value;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1dup
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_encoding
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1encoding
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_free
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1free
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_frombind
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1frombind
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_int
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1int
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_int64
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1int64
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_java_object
+ * Signature: (J)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1java_1object
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_nio_buffer
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3_value;)Ljava/nio/ByteBuffer;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1nio_1buffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_nochange
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1nochange
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_numeric_type
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1numeric_1type
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_subtype
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1subtype
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_text
+ * Signature: (J)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1text
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_text16
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1text16
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_value_type
+ * Signature: (J)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1value_1type
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_sqlite_jni_capi_CApi
+ * Method:    sqlite3_jni_internal_details
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1jni_1internal_1details
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_sqlite_jni_capi_SQLTester */
+
+#ifndef _Included_org_sqlite_jni_capi_SQLTester
+#define _Included_org_sqlite_jni_capi_SQLTester
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_sqlite_jni_capi_SQLTester
+ * Method:    strglob
+ * Signature: ([B[B)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_SQLTester_strglob
+  (JNIEnv *, jclass, jbyteArray, jbyteArray);
+
+/*
+ * Class:     org_sqlite_jni_capi_SQLTester
+ * Method:    installCustomExtensions
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_capi_SQLTester_installCustomExtensions
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_sqlite_jni_fts5_Fts5ExtensionApi */
+
+#ifndef _Included_org_sqlite_jni_fts5_Fts5ExtensionApi
+#define _Included_org_sqlite_jni_fts5_Fts5ExtensionApi
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    getInstance
+ * Signature: ()Lorg/sqlite/jni/fts5/Fts5ExtensionApi;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_getInstance
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xColumnCount
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xColumnCount
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xColumnSize
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xColumnSize
+  (JNIEnv *, jobject, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xColumnText
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/capi/OutputPointer/String;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xColumnText
+  (JNIEnv *, jobject, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xColumnTotalSize
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/capi/OutputPointer/Int64;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xColumnTotalSize
+  (JNIEnv *, jobject, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xGetAuxdata
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Z)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xGetAuxdata
+  (JNIEnv *, jobject, jobject, jboolean);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xInst
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xInst
+  (JNIEnv *, jobject, jobject, jint, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xInstCount
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xInstCount
+  (JNIEnv *, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseCount
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseCount
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseFirst
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/fts5/Fts5PhraseIter;Lorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseFirst
+  (JNIEnv *, jobject, jobject, jint, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseFirstColumn
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/fts5/Fts5PhraseIter;Lorg/sqlite/jni/capi/OutputPointer/Int32;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseFirstColumn
+  (JNIEnv *, jobject, jobject, jint, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseNext
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Lorg/sqlite/jni/fts5/Fts5PhraseIter;Lorg/sqlite/jni/capi/OutputPointer/Int32;Lorg/sqlite/jni/capi/OutputPointer/Int32;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseNext
+  (JNIEnv *, jobject, jobject, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseNextColumn
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Lorg/sqlite/jni/fts5/Fts5PhraseIter;Lorg/sqlite/jni/capi/OutputPointer/Int32;)V
+ */
+JNIEXPORT void JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseNextColumn
+  (JNIEnv *, jobject, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xPhraseSize
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;I)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xPhraseSize
+  (JNIEnv *, jobject, jobject, jint);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xQueryPhrase
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;ILorg/sqlite/jni/fts5/Fts5ExtensionApi/XQueryPhraseCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xQueryPhrase
+  (JNIEnv *, jobject, jobject, jint, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xRowCount
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Lorg/sqlite/jni/capi/OutputPointer/Int64;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xRowCount
+  (JNIEnv *, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xRowid
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;)J
+ */
+JNIEXPORT jlong JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xRowid
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xSetAuxdata
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;Ljava/lang/Object;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xSetAuxdata
+  (JNIEnv *, jobject, jobject, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xTokenize
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;[BLorg/sqlite/jni/fts5/XTokenizeCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xTokenize
+  (JNIEnv *, jobject, jobject, jbyteArray, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_Fts5ExtensionApi
+ * Method:    xUserData
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Context;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_fts5_Fts5ExtensionApi_xUserData
+  (JNIEnv *, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_sqlite_jni_fts5_fts5_api */
+
+#ifndef _Included_org_sqlite_jni_fts5_fts5_api
+#define _Included_org_sqlite_jni_fts5_fts5_api
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef org_sqlite_jni_fts5_fts5_api_iVersion
+#define org_sqlite_jni_fts5_fts5_api_iVersion 2L
+/*
+ * Class:     org_sqlite_jni_fts5_fts5_api
+ * Method:    getInstanceForDb
+ * Signature: (Lorg/sqlite/jni/capi/sqlite3;)Lorg/sqlite/jni/fts5/fts5_api;
+ */
+JNIEXPORT jobject JNICALL Java_org_sqlite_jni_fts5_fts5_1api_getInstanceForDb
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     org_sqlite_jni_fts5_fts5_api
+ * Method:    xCreateFunction
+ * Signature: (Ljava/lang/String;Ljava/lang/Object;Lorg/sqlite/jni/fts5/fts5_extension_function;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_fts5_1api_xCreateFunction
+  (JNIEnv *, jobject, jstring, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_sqlite_jni_fts5_fts5_tokenizer */
+
+#ifndef _Included_org_sqlite_jni_fts5_fts5_tokenizer
+#define _Included_org_sqlite_jni_fts5_fts5_tokenizer
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_sqlite_jni_fts5_fts5_tokenizer
+ * Method:    xTokenize
+ * Signature: (Lorg/sqlite/jni/fts5/Fts5Tokenizer;I[BLorg/sqlite/jni/fts5/XTokenizeCallback;)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_fts5_1tokenizer_xTokenize
+  (JNIEnv *, jobject, jobject, jint, jbyteArray, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/SQLTester/index.html

@@ -0,0 +1,125 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+    <!--link rel="stylesheet" href="../common/emscripten.css"/-->
+    <link rel="stylesheet" href="../common/testing.css"/>
+    <title>SQLTester</title>
+  </head>
+  <style>
+    fieldset {
+        display: flex;
+        flex-direction: row;
+        padding-right: 1em;
+    }
+    fieldset > :not(.legend) {
+        display: flex;
+        flex-direction: row;
+        padding-right: 1em;
+    }
+  </style>
+  <body>
+    <h1>SQLTester for JS/WASM</h1>
+    <p>This app reads in a build-time-defined set of SQLTester test
+      scripts and runs them through the test suite.
+    </p>
+    <fieldset>
+      <legend>Options</legend>
+      <span class='input-wrapper'>
+        <input type='checkbox' id='cb-log-reverse' checked>
+        <label for='cb-log-reverse'>Reverse log order?</label>
+      </span>
+      <input type='button' id='btn-run-tests' value='Run tests'/>
+    </fieldset>
+    <div id='test-output'>Test output will go here.</div>
+    <!--script src='SQLTester.run.mjs' type='module'></script-->
+    <script>
+      (async function(){
+        const W = new Worker('SQLTester.run.mjs',{
+          type: 'module'
+        });
+        const wPost = (type,payload)=>W.postMessage({type,payload});
+        const mapToString = (v)=>{
+          switch(typeof v){
+            case 'string': return v;
+            case 'number': case 'boolean':
+            case 'undefined': case 'bigint':
+              return ''+v;
+            default: break;
+          }
+          if(null===v) return 'null';
+          if(v instanceof Error){
+            v = {
+              message: v.message,
+              stack: v.stack,
+              errorClass: v.name
+            };
+          }
+          return JSON.stringify(v,undefined,2);
+        };
+        const normalizeArgs = (args)=>args.map(mapToString);
+        const logTarget = document.querySelector('#test-output');
+        const logClass = function(cssClass,...args){
+          const ln = document.createElement('div');
+          if(cssClass){
+            for(const c of (Array.isArray(cssClass) ? cssClass : [cssClass])){
+              ln.classList.add(c);
+            }
+          }
+          ln.append(document.createTextNode(normalizeArgs(args).join(' ')));
+          logTarget.append(ln);
+        };
+        {
+          const cbReverse = document.querySelector('#cb-log-reverse');
+          const cbReverseKey = 'SQLTester:cb-log-reverse';
+          const cbReverseIt = ()=>{
+            logTarget.classList[cbReverse.checked ? 'add' : 'remove']('reverse');
+          };
+          cbReverse.addEventListener('change', cbReverseIt, true);
+          cbReverseIt();
+        }
+
+        const btnRun = document.querySelector('#btn-run-tests');
+        const runTests = ()=>{
+          btnRun.setAttribute('disabled','disabled');
+          wPost('run-tests');
+          logTarget.innerText = 'Running tests...';
+        }
+        btnRun.addEventListener('click', runTests);
+        const log2 = function f(...args){
+          logClass('', ...args);
+          return f;
+        };
+        const log = function f(...args){
+          logClass('','index.html:',...args);
+          return f;
+        };
+
+        const timerId = setTimeout( ()=>{
+          logClass('error',"The SQLTester module is taking an unusually ",
+                   "long time to load. More information may be available",
+                   "in the dev console.");
+        }, 3000 /* assuming localhost */ );
+
+        W.onmessage = function({data}){
+          switch(data.type){
+            case 'stdout': log2(data.payload.message); break;
+            case 'tests-end':
+              btnRun.removeAttribute('disabled');
+              delete data.payload.nTest;
+              log("test results:",data.payload);
+              break;
+            case 'is-ready':
+              clearTimeout(timerId);
+              runTests(); break;
+            default:
+              log("unhandled onmessage",data);
+              break;
+          }
+        };
+      })();
+    </script>
+  </body>
+</html>

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/SQLTester/touint8array.c

@@ -0,0 +1,29 @@
+/*
+** 2023-08-29
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** This file contains a tool for writing out the contents of stdin as
+** a comma-separated list of numbers, one per byte.
+*/
+
+#include <stdio.h>
+int main(int argc, char const **argv){
+  int i;
+  int rc = 0, colWidth = 30;
+  int ch;
+  printf("[");
+  for( i=0; EOF!=(ch = fgetc(stdin)); ++i ){
+    if( 0!=i ) printf(",");
+    if( i && 0==(i%colWidth) ) puts("");
+    printf("%d",ch);
+  }
+  printf("]");
+  return rc;
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/post-js-header.js

@@ -0,0 +1,28 @@
+/**
+   post-js-header.js is to be prepended to other code to create
+   post-js.js for use with Emscripten's --post-js flag. This code
+   requires that it be running in that context. The Emscripten
+   environment must have been set up already but it will not have
+   loaded its WASM when the code in this file is run. The function it
+   installs will be run after the WASM module is loaded, at which
+   point the sqlite3 JS API bits will get set up.
+*/
+if(!Module.postRun) Module.postRun = [];
+Module.postRun.push(function(Module/*the Emscripten-style module object*/){
+  'use strict';
+  /* This function will contain at least the following:
+
+     - post-js-header.js (this file)
+     - sqlite3-api-prologue.js  => Bootstrapping bits to attach the rest to
+     - common/whwasmutil.js     => Replacements for much of Emscripten's glue
+     - jaccwaby/jaccwabyt.js    => Jaccwabyt (C/JS struct binding)
+     - sqlite3-api-glue.js      => glues previous parts together
+     - sqlite3-api-oo.js        => SQLite3 OO API #1
+     - sqlite3-api-worker1.js   => Worker-based API
+     - sqlite3-vfs-helper.c-pp.js  => Utilities for VFS impls
+     - sqlite3-vtab-helper.c-pp.js => Utilities for virtual table impls
+     - sqlite3-vfs-opfs.c-pp.js  => OPFS VFS
+     - sqlite3-vfs-opfs-sahpool.c-pp.js => OPFS SAHPool VFS
+     - sqlite3-api-cleanup.js   => final API cleanup
+     - post-js-footer.js        => closes this postRun() function
+  */

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js

@@ -0,0 +1,1457 @@
+//#ifnot target=node
+/*
+  2022-09-18
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This file holds the synchronous half of an sqlite3_vfs
+  implementation which proxies, in a synchronous fashion, the
+  asynchronous Origin-Private FileSystem (OPFS) APIs using a second
+  Worker, implemented in sqlite3-opfs-async-proxy.js.  This file is
+  intended to be appended to the main sqlite3 JS deliverable somewhere
+  after sqlite3-api-oo1.js and before sqlite3-api-cleanup.js.
+*/
+'use strict';
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+/**
+   installOpfsVfs() returns a Promise which, on success, installs an
+   sqlite3_vfs named "opfs", suitable for use with all sqlite3 APIs
+   which accept a VFS. It is intended to be called via
+   sqlite3ApiBootstrap.initializers or an equivalent mechanism.
+
+   The installed VFS uses the Origin-Private FileSystem API for
+   all file storage. On error it is rejected with an exception
+   explaining the problem. Reasons for rejection include, but are
+   not limited to:
+
+   - The counterpart Worker (see below) could not be loaded.
+
+   - The environment does not support OPFS. That includes when
+     this function is called from the main window thread.
+
+  Significant notes and limitations:
+
+  - The OPFS features used here are only available in dedicated Worker
+    threads. This file tries to detect that case, resulting in a
+    rejected Promise if those features do not seem to be available.
+
+  - It requires the SharedArrayBuffer and Atomics classes, and the
+    former is only available if the HTTP server emits the so-called
+    COOP and COEP response headers. These features are required for
+    proxying OPFS's synchronous API via the synchronous interface
+    required by the sqlite3_vfs API.
+
+  - This function may only be called a single time. When called, this
+    function removes itself from the sqlite3 object.
+
+  All arguments to this function are for internal/development purposes
+  only. They do not constitute a public API and may change at any
+  time.
+
+  The argument may optionally be a plain object with the following
+  configuration options:
+
+  - proxyUri: name of the async proxy JS file.
+
+  - verbose (=2): an integer 0-3. 0 disables all logging, 1 enables
+    logging of errors. 2 enables logging of warnings and errors. 3
+    additionally enables debugging info. Logging is performed
+    via the sqlite3.config.{log|warn|error}() functions.
+
+  - sanityChecks (=false): if true, some basic sanity tests are run on
+    the OPFS VFS API after it's initialized, before the returned
+    Promise resolves. This is only intended for testing and
+    development of the VFS, not client-side use.
+
+  On success, the Promise resolves to the top-most sqlite3 namespace
+  object and that object gets a new object installed in its
+  `opfs` property, containing several OPFS-specific utilities.
+*/
+const installOpfsVfs = function callee(options){
+  if(!globalThis.SharedArrayBuffer
+    || !globalThis.Atomics){
+    return Promise.reject(
+      new Error("Cannot install OPFS: Missing SharedArrayBuffer and/or Atomics. "+
+                "The server must emit the COOP/COEP response headers to enable those. "+
+                "See https://sqlite.org/wasm/doc/trunk/persistence.md#coop-coep")
+    );
+  }else if('undefined'===typeof WorkerGlobalScope){
+    return Promise.reject(
+      new Error("The OPFS sqlite3_vfs cannot run in the main thread "+
+                "because it requires Atomics.wait().")
+    );
+  }else if(!globalThis.FileSystemHandle ||
+           !globalThis.FileSystemDirectoryHandle ||
+           !globalThis.FileSystemFileHandle ||
+           !globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle ||
+           !navigator?.storage?.getDirectory){
+    return Promise.reject(
+      new Error("Missing required OPFS APIs.")
+    );
+  }
+  if(!options || 'object'!==typeof options){
+    options = Object.create(null);
+  }
+  const urlParams = new URL(globalThis.location.href).searchParams;
+  if(urlParams.has('opfs-disable')){
+    //sqlite3.config.warn('Explicitly not installing "opfs" VFS due to opfs-disable flag.');
+    return Promise.resolve(sqlite3);
+  }
+  if(undefined===options.verbose){
+    options.verbose = urlParams.has('opfs-verbose')
+      ? (+urlParams.get('opfs-verbose') || 2) : 1;
+  }
+  if(undefined===options.sanityChecks){
+    options.sanityChecks = urlParams.has('opfs-sanity-check');
+  }
+  if(undefined===options.proxyUri){
+    options.proxyUri = callee.defaultProxyUri;
+  }
+
+  //sqlite3.config.warn("OPFS options =",options,globalThis.location);
+
+  if('function' === typeof options.proxyUri){
+    options.proxyUri = options.proxyUri();
+  }
+  const thePromise = new Promise(function(promiseResolve_, promiseReject_){
+    const loggers = [
+      sqlite3.config.error,
+      sqlite3.config.warn,
+      sqlite3.config.log
+    ];
+    const logImpl = (level,...args)=>{
+      if(options.verbose>level) loggers[level]("OPFS syncer:",...args);
+    };
+    const log =    (...args)=>logImpl(2, ...args);
+    const warn =   (...args)=>logImpl(1, ...args);
+    const error =  (...args)=>logImpl(0, ...args);
+    const toss = sqlite3.util.toss;
+    const capi = sqlite3.capi;
+    const util = sqlite3.util;
+    const wasm = sqlite3.wasm;
+    const sqlite3_vfs = capi.sqlite3_vfs;
+    const sqlite3_file = capi.sqlite3_file;
+    const sqlite3_io_methods = capi.sqlite3_io_methods;
+    /**
+       Generic utilities for working with OPFS. This will get filled out
+       by the Promise setup and, on success, installed as sqlite3.opfs.
+
+       ACHTUNG: do not rely on these APIs in client code. They are
+       experimental and subject to change or removal as the
+       OPFS-specific sqlite3_vfs evolves.
+    */
+    const opfsUtil = Object.create(null);
+
+    /**
+       Returns true if _this_ thread has access to the OPFS APIs.
+    */
+    const thisThreadHasOPFS = ()=>{
+      return globalThis.FileSystemHandle &&
+        globalThis.FileSystemDirectoryHandle &&
+        globalThis.FileSystemFileHandle &&
+        globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle &&
+        navigator?.storage?.getDirectory;
+    };
+
+    /**
+       Not part of the public API. Solely for internal/development
+       use.
+    */
+    opfsUtil.metrics = {
+      dump: function(){
+        let k, n = 0, t = 0, w = 0;
+        for(k in state.opIds){
+          const m = metrics[k];
+          n += m.count;
+          t += m.time;
+          w += m.wait;
+          m.avgTime = (m.count && m.time) ? (m.time / m.count) : 0;
+          m.avgWait = (m.count && m.wait) ? (m.wait / m.count) : 0;
+        }
+        sqlite3.config.log(globalThis.location.href,
+                    "metrics for",globalThis.location.href,":",metrics,
+                    "\nTotal of",n,"op(s) for",t,
+                    "ms (incl. "+w+" ms of waiting on the async side)");
+        sqlite3.config.log("Serialization metrics:",metrics.s11n);
+        W.postMessage({type:'opfs-async-metrics'});
+      },
+      reset: function(){
+        let k;
+        const r = (m)=>(m.count = m.time = m.wait = 0);
+        for(k in state.opIds){
+          r(metrics[k] = Object.create(null));
+        }
+        let s = metrics.s11n = Object.create(null);
+        s = s.serialize = Object.create(null);
+        s.count = s.time = 0;
+        s = metrics.s11n.deserialize = Object.create(null);
+        s.count = s.time = 0;
+      }
+    }/*metrics*/;
+    const opfsIoMethods = new sqlite3_io_methods();
+    const opfsVfs = new sqlite3_vfs()
+          .addOnDispose( ()=>opfsIoMethods.dispose());
+    let promiseWasRejected = undefined;
+    const promiseReject = (err)=>{
+      promiseWasRejected = true;
+      opfsVfs.dispose();
+      return promiseReject_(err);
+    };
+    const promiseResolve = ()=>{
+      promiseWasRejected = false;
+      return promiseResolve_(sqlite3);
+    };
+    const W =
+//#if target=es6-bundler-friendly
+    new Worker(new URL("sqlite3-opfs-async-proxy.js", import.meta.url));
+//#elif target=es6-module
+    new Worker(new URL(options.proxyUri, import.meta.url));
+//#else
+    new Worker(options.proxyUri);
+//#endif
+    setTimeout(()=>{
+      /* At attempt to work around a browser-specific quirk in which
+         the Worker load is failing in such a way that we neither
+         resolve nor reject it. This workaround gives that resolve/reject
+         a time limit and rejects if that timer expires. Discussion:
+         https://sqlite.org/forum/forumpost/a708c98dcb3ef */
+      if(undefined===promiseWasRejected){
+        promiseReject(
+          new Error("Timeout while waiting for OPFS async proxy worker.")
+        );
+      }
+    }, 4000);
+    W._originalOnError = W.onerror /* will be restored later */;
+    W.onerror = function(err){
+      // The error object doesn't contain any useful info when the
+      // failure is, e.g., that the remote script is 404.
+      error("Error initializing OPFS asyncer:",err);
+      promiseReject(new Error("Loading OPFS async Worker failed for unknown reasons."));
+    };
+    const pDVfs = capi.sqlite3_vfs_find(null)/*pointer to default VFS*/;
+    const dVfs = pDVfs
+          ? new sqlite3_vfs(pDVfs)
+          : null /* dVfs will be null when sqlite3 is built with
+                    SQLITE_OS_OTHER. */;
+    opfsIoMethods.$iVersion = 1;
+    opfsVfs.$iVersion = 2/*yes, two*/;
+    opfsVfs.$szOsFile = capi.sqlite3_file.structInfo.sizeof;
+    opfsVfs.$mxPathname = 1024/* sure, why not? The OPFS name length limit
+                                 is undocumented/unspecified. */;
+    opfsVfs.$zName = wasm.allocCString("opfs");
+    // All C-side memory of opfsVfs is zeroed out, but just to be explicit:
+    opfsVfs.$xDlOpen = opfsVfs.$xDlError = opfsVfs.$xDlSym = opfsVfs.$xDlClose = null;
+    opfsVfs.addOnDispose(
+      '$zName', opfsVfs.$zName,
+      'cleanup default VFS wrapper', ()=>(dVfs ? dVfs.dispose() : null)
+    );
+    /**
+       Pedantic sidebar about opfsVfs.ondispose: the entries in that array
+       are items to clean up when opfsVfs.dispose() is called, but in this
+       environment it will never be called. The VFS instance simply
+       hangs around until the WASM module instance is cleaned up. We
+       "could" _hypothetically_ clean it up by "importing" an
+       sqlite3_os_end() impl into the wasm build, but the shutdown order
+       of the wasm engine and the JS one are undefined so there is no
+       guaranty that the opfsVfs instance would be available in one
+       environment or the other when sqlite3_os_end() is called (_if_ it
+       gets called at all in a wasm build, which is undefined).
+    */
+    /**
+       State which we send to the async-api Worker or share with it.
+       This object must initially contain only cloneable or sharable
+       objects. After the worker's "inited" message arrives, other types
+       of data may be added to it.
+
+       For purposes of Atomics.wait() and Atomics.notify(), we use a
+       SharedArrayBuffer with one slot reserved for each of the API
+       proxy's methods. The sync side of the API uses Atomics.wait()
+       on the corresponding slot and the async side uses
+       Atomics.notify() on that slot.
+
+       The approach of using a single SAB to serialize comms for all
+       instances might(?) lead to deadlock situations in multi-db
+       cases. We should probably have one SAB here with a single slot
+       for locking a per-file initialization step and then allocate a
+       separate SAB like the above one for each file. That will
+       require a bit of acrobatics but should be feasible. The most
+       problematic part is that xOpen() would have to use
+       postMessage() to communicate its SharedArrayBuffer, and mixing
+       that approach with Atomics.wait/notify() gets a bit messy.
+    */
+    const state = Object.create(null);
+    state.verbose = options.verbose;
+    state.littleEndian = (()=>{
+      const buffer = new ArrayBuffer(2);
+      new DataView(buffer).setInt16(0, 256, true /* ==>littleEndian */);
+      // Int16Array uses the platform's endianness.
+      return new Int16Array(buffer)[0] === 256;
+    })();
+    /**
+       asyncIdleWaitTime is how long (ms) to wait, in the async proxy,
+       for each Atomics.wait() when waiting on inbound VFS API calls.
+       We need to wake up periodically to give the thread a chance to
+       do other things. If this is too high (e.g. 500ms) then even two
+       workers/tabs can easily run into locking errors. Some multiple
+       of this value is also used for determining how long to wait on
+       lock contention to free up.
+    */
+    state.asyncIdleWaitTime = 150;
+
+    /**
+       Whether the async counterpart should log exceptions to
+       the serialization channel. That produces a great deal of
+       noise for seemingly innocuous things like xAccess() checks
+       for missing files, so this option may have one of 3 values:
+
+       0 = no exception logging.
+
+       1 = only log exceptions for "significant" ops like xOpen(),
+       xRead(), and xWrite().
+
+       2 = log all exceptions.
+    */
+    state.asyncS11nExceptions = 1;
+    /* Size of file I/O buffer block. 64k = max sqlite3 page size, and
+       xRead/xWrite() will never deal in blocks larger than that. */
+    state.fileBufferSize = 1024 * 64;
+    state.sabS11nOffset = state.fileBufferSize;
+    /**
+       The size of the block in our SAB for serializing arguments and
+       result values. Needs to be large enough to hold serialized
+       values of any of the proxied APIs. Filenames are the largest
+       part but are limited to opfsVfs.$mxPathname bytes. We also
+       store exceptions there, so it needs to be long enough to hold
+       a reasonably long exception string.
+    */
+    state.sabS11nSize = opfsVfs.$mxPathname * 2;
+    /**
+       The SAB used for all data I/O between the synchronous and
+       async halves (file i/o and arg/result s11n).
+    */
+    state.sabIO = new SharedArrayBuffer(
+      state.fileBufferSize/* file i/o block */
+      + state.sabS11nSize/* argument/result serialization block */
+    );
+    state.opIds = Object.create(null);
+    const metrics = Object.create(null);
+    {
+      /* Indexes for use in our SharedArrayBuffer... */
+      let i = 0;
+      /* SAB slot used to communicate which operation is desired
+         between both workers. This worker writes to it and the other
+         listens for changes. */
+      state.opIds.whichOp = i++;
+      /* Slot for storing return values. This worker listens to that
+         slot and the other worker writes to it. */
+      state.opIds.rc = i++;
+      /* Each function gets an ID which this worker writes to
+         the whichOp slot. The async-api worker uses Atomic.wait()
+         on the whichOp slot to figure out which operation to run
+         next. */
+      state.opIds.xAccess = i++;
+      state.opIds.xClose = i++;
+      state.opIds.xDelete = i++;
+      state.opIds.xDeleteNoWait = i++;
+      state.opIds.xFileSize = i++;
+      state.opIds.xLock = i++;
+      state.opIds.xOpen = i++;
+      state.opIds.xRead = i++;
+      state.opIds.xSleep = i++;
+      state.opIds.xSync = i++;
+      state.opIds.xTruncate = i++;
+      state.opIds.xUnlock = i++;
+      state.opIds.xWrite = i++;
+      state.opIds.mkdir = i++;
+      state.opIds['opfs-async-metrics'] = i++;
+      state.opIds['opfs-async-shutdown'] = i++;
+      /* The retry slot is used by the async part for wait-and-retry
+         semantics. Though we could hypothetically use the xSleep slot
+         for that, doing so might lead to undesired side effects. */
+      state.opIds.retry = i++;
+      state.sabOP = new SharedArrayBuffer(
+        i * 4/* ==sizeof int32, noting that Atomics.wait() and friends
+                can only function on Int32Array views of an SAB. */);
+      opfsUtil.metrics.reset();
+    }
+    /**
+       SQLITE_xxx constants to export to the async worker
+       counterpart...
+    */
+    state.sq3Codes = Object.create(null);
+    [
+      'SQLITE_ACCESS_EXISTS',
+      'SQLITE_ACCESS_READWRITE',
+      'SQLITE_BUSY',
+      'SQLITE_CANTOPEN',
+      'SQLITE_ERROR',
+      'SQLITE_IOERR',
+      'SQLITE_IOERR_ACCESS',
+      'SQLITE_IOERR_CLOSE',
+      'SQLITE_IOERR_DELETE',
+      'SQLITE_IOERR_FSYNC',
+      'SQLITE_IOERR_LOCK',
+      'SQLITE_IOERR_READ',
+      'SQLITE_IOERR_SHORT_READ',
+      'SQLITE_IOERR_TRUNCATE',
+      'SQLITE_IOERR_UNLOCK',
+      'SQLITE_IOERR_WRITE',
+      'SQLITE_LOCK_EXCLUSIVE',
+      'SQLITE_LOCK_NONE',
+      'SQLITE_LOCK_PENDING',
+      'SQLITE_LOCK_RESERVED',
+      'SQLITE_LOCK_SHARED',
+      'SQLITE_LOCKED',
+      'SQLITE_MISUSE',
+      'SQLITE_NOTFOUND',
+      'SQLITE_OPEN_CREATE',
+      'SQLITE_OPEN_DELETEONCLOSE',
+      'SQLITE_OPEN_MAIN_DB',
+      'SQLITE_OPEN_READONLY'
+    ].forEach((k)=>{
+      if(undefined === (state.sq3Codes[k] = capi[k])){
+        toss("Maintenance required: not found:",k);
+      }
+    });
+    state.opfsFlags = Object.assign(Object.create(null),{
+      /**
+         Flag for use with xOpen(). URI flag "opfs-unlock-asap=1"
+         enables this. See defaultUnlockAsap, below.
+       */
+      OPFS_UNLOCK_ASAP: 0x01,
+      /**
+         Flag for use with xOpen(). URI flag "delete-before-open=1"
+         tells the VFS to delete the db file before attempting to open
+         it. This can be used, e.g., to replace a db which has been
+         corrupted (without forcing us to expose a delete/unlink()
+         function in the public API).
+
+         Failure to unlink the file is ignored but may lead to
+         downstream errors.  An unlink can fail if, e.g., another tab
+         has the handle open.
+
+         It goes without saying that deleting a file out from under another
+         instance results in Undefined Behavior.
+      */
+      OPFS_UNLINK_BEFORE_OPEN: 0x02,
+      /**
+         If true, any async routine which implicitly acquires a sync
+         access handle (i.e. an OPFS lock) will release that lock at
+         the end of the call which acquires it. If false, such
+         "autolocks" are not released until the VFS is idle for some
+         brief amount of time.
+
+         The benefit of enabling this is much higher concurrency. The
+         down-side is much-reduced performance (as much as a 4x decrease
+         in speedtest1).
+      */
+      defaultUnlockAsap: false
+    });
+
+    /**
+       Runs the given operation (by name) in the async worker
+       counterpart, waits for its response, and returns the result
+       which the async worker writes to SAB[state.opIds.rc]. The
+       2nd and subsequent arguments must be the aruguments for the
+       async op.
+    */
+    const opRun = (op,...args)=>{
+      const opNdx = state.opIds[op] || toss("Invalid op ID:",op);
+      state.s11n.serialize(...args);
+      Atomics.store(state.sabOPView, state.opIds.rc, -1);
+      Atomics.store(state.sabOPView, state.opIds.whichOp, opNdx);
+      Atomics.notify(state.sabOPView, state.opIds.whichOp)
+      /* async thread will take over here */;
+      const t = performance.now();
+      while('not-equal'!==Atomics.wait(state.sabOPView, state.opIds.rc, -1)){
+        /*
+          The reason for this loop is buried in the details of a long
+          discussion at:
+
+          https://github.com/sqlite/sqlite-wasm/issues/12
+
+          Summary: in at least one browser flavor, under high loads,
+          the wait()/notify() pairings can get out of sync. Calling
+          wait() here until it returns 'not-equal' gets them back in
+          sync.
+        */
+      }
+      /* When the above wait() call returns 'not-equal', the async
+         half will have completed the operation and reported its results
+         in the state.opIds.rc slot of the SAB. */
+      const rc = Atomics.load(state.sabOPView, state.opIds.rc);
+      metrics[op].wait += performance.now() - t;
+      if(rc && state.asyncS11nExceptions){
+        const err = state.s11n.deserialize();
+        if(err) error(op+"() async error:",...err);
+      }
+      return rc;
+    };
+
+    /**
+       Not part of the public API. Only for test/development use.
+    */
+    opfsUtil.debug = {
+      asyncShutdown: ()=>{
+        warn("Shutting down OPFS async listener. The OPFS VFS will no longer work.");
+        opRun('opfs-async-shutdown');
+      },
+      asyncRestart: ()=>{
+        warn("Attempting to restart OPFS VFS async listener. Might work, might not.");
+        W.postMessage({type: 'opfs-async-restart'});
+      }
+    };
+
+    const initS11n = ()=>{
+      /**
+         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+         ACHTUNG: this code is 100% duplicated in the other half of
+         this proxy! The documentation is maintained in the
+         "synchronous half".
+         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+         This proxy de/serializes cross-thread function arguments and
+         output-pointer values via the state.sabIO SharedArrayBuffer,
+         using the region defined by (state.sabS11nOffset,
+         state.sabS11nOffset + state.sabS11nSize]. Only one dataset is
+         recorded at a time.
+
+         This is not a general-purpose format. It only supports the
+         range of operations, and data sizes, needed by the
+         sqlite3_vfs and sqlite3_io_methods operations. Serialized
+         data are transient and this serialization algorithm may
+         change at any time.
+
+         The data format can be succinctly summarized as:
+
+         Nt...Td...D
+
+         Where:
+
+         - N = number of entries (1 byte)
+
+         - t = type ID of first argument (1 byte)
+
+         - ...T = type IDs of the 2nd and subsequent arguments (1 byte
+         each).
+
+         - d = raw bytes of first argument (per-type size).
+
+         - ...D = raw bytes of the 2nd and subsequent arguments (per-type
+         size).
+
+         All types except strings have fixed sizes. Strings are stored
+         using their TextEncoder/TextDecoder representations. It would
+         arguably make more sense to store them as Int16Arrays of
+         their JS character values, but how best/fastest to get that
+         in and out of string form is an open point. Initial
+         experimentation with that approach did not gain us any speed.
+
+         Historical note: this impl was initially about 1% this size by
+         using using JSON.stringify/parse(), but using fit-to-purpose
+         serialization saves considerable runtime.
+      */
+      if(state.s11n) return state.s11n;
+      const textDecoder = new TextDecoder(),
+            textEncoder = new TextEncoder('utf-8'),
+            viewU8 = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize),
+            viewDV = new DataView(state.sabIO, state.sabS11nOffset, state.sabS11nSize);
+      state.s11n = Object.create(null);
+      /* Only arguments and return values of these types may be
+         serialized. This covers the whole range of types needed by the
+         sqlite3_vfs API. */
+      const TypeIds = Object.create(null);
+      TypeIds.number  = { id: 1, size: 8, getter: 'getFloat64', setter: 'setFloat64' };
+      TypeIds.bigint  = { id: 2, size: 8, getter: 'getBigInt64', setter: 'setBigInt64' };
+      TypeIds.boolean = { id: 3, size: 4, getter: 'getInt32', setter: 'setInt32' };
+      TypeIds.string =  { id: 4 };
+
+      const getTypeId = (v)=>(
+        TypeIds[typeof v]
+          || toss("Maintenance required: this value type cannot be serialized.",v)
+      );
+      const getTypeIdById = (tid)=>{
+        switch(tid){
+            case TypeIds.number.id: return TypeIds.number;
+            case TypeIds.bigint.id: return TypeIds.bigint;
+            case TypeIds.boolean.id: return TypeIds.boolean;
+            case TypeIds.string.id: return TypeIds.string;
+            default: toss("Invalid type ID:",tid);
+        }
+      };
+
+      /**
+         Returns an array of the deserialized state stored by the most
+         recent serialize() operation (from from this thread or the
+         counterpart thread), or null if the serialization buffer is
+         empty.  If passed a truthy argument, the serialization buffer
+         is cleared after deserialization.
+      */
+      state.s11n.deserialize = function(clear=false){
+        ++metrics.s11n.deserialize.count;
+        const t = performance.now();
+        const argc = viewU8[0];
+        const rc = argc ? [] : null;
+        if(argc){
+          const typeIds = [];
+          let offset = 1, i, n, v;
+          for(i = 0; i < argc; ++i, ++offset){
+            typeIds.push(getTypeIdById(viewU8[offset]));
+          }
+          for(i = 0; i < argc; ++i){
+            const t = typeIds[i];
+            if(t.getter){
+              v = viewDV[t.getter](offset, state.littleEndian);
+              offset += t.size;
+            }else{/*String*/
+              n = viewDV.getInt32(offset, state.littleEndian);
+              offset += 4;
+              v = textDecoder.decode(viewU8.slice(offset, offset+n));
+              offset += n;
+            }
+            rc.push(v);
+          }
+        }
+        if(clear) viewU8[0] = 0;
+        //log("deserialize:",argc, rc);
+        metrics.s11n.deserialize.time += performance.now() - t;
+        return rc;
+      };
+
+      /**
+         Serializes all arguments to the shared buffer for consumption
+         by the counterpart thread.
+
+         This routine is only intended for serializing OPFS VFS
+         arguments and (in at least one special case) result values,
+         and the buffer is sized to be able to comfortably handle
+         those.
+
+         If passed no arguments then it zeroes out the serialization
+         state.
+      */
+      state.s11n.serialize = function(...args){
+        const t = performance.now();
+        ++metrics.s11n.serialize.count;
+        if(args.length){
+          //log("serialize():",args);
+          const typeIds = [];
+          let i = 0, offset = 1;
+          viewU8[0] = args.length & 0xff /* header = # of args */;
+          for(; i < args.length; ++i, ++offset){
+            /* Write the TypeIds.id value into the next args.length
+               bytes. */
+            typeIds.push(getTypeId(args[i]));
+            viewU8[offset] = typeIds[i].id;
+          }
+          for(i = 0; i < args.length; ++i) {
+            /* Deserialize the following bytes based on their
+               corresponding TypeIds.id from the header. */
+            const t = typeIds[i];
+            if(t.setter){
+              viewDV[t.setter](offset, args[i], state.littleEndian);
+              offset += t.size;
+            }else{/*String*/
+              const s = textEncoder.encode(args[i]);
+              viewDV.setInt32(offset, s.byteLength, state.littleEndian);
+              offset += 4;
+              viewU8.set(s, offset);
+              offset += s.byteLength;
+            }
+          }
+          //log("serialize() result:",viewU8.slice(0,offset));
+        }else{
+          viewU8[0] = 0;
+        }
+        metrics.s11n.serialize.time += performance.now() - t;
+      };
+      return state.s11n;
+    }/*initS11n()*/;
+
+    /**
+       Generates a random ASCII string len characters long, intended for
+       use as a temporary file name.
+    */
+    const randomFilename = function f(len=16){
+      if(!f._chars){
+        f._chars = "abcdefghijklmnopqrstuvwxyz"+
+          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"+
+          "012346789";
+        f._n = f._chars.length;
+      }
+      const a = [];
+      let i = 0;
+      for( ; i < len; ++i){
+        const ndx = Math.random() * (f._n * 64) % f._n | 0;
+        a[i] = f._chars[ndx];
+      }
+      return a.join("");
+      /*
+        An alternative impl. with an unpredictable length
+        but much simpler:
+
+        Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36)
+      */
+    };
+
+    /**
+       Map of sqlite3_file pointers to objects constructed by xOpen().
+    */
+    const __openFiles = Object.create(null);
+
+    const opTimer = Object.create(null);
+    opTimer.op = undefined;
+    opTimer.start = undefined;
+    const mTimeStart = (op)=>{
+      opTimer.start = performance.now();
+      opTimer.op = op;
+      ++metrics[op].count;
+    };
+    const mTimeEnd = ()=>(
+      metrics[opTimer.op].time += performance.now() - opTimer.start
+    );
+
+    /**
+       Impls for the sqlite3_io_methods methods. Maintenance reminder:
+       members are in alphabetical order to simplify finding them.
+    */
+    const ioSyncWrappers = {
+      xCheckReservedLock: function(pFile,pOut){
+        /**
+           As of late 2022, only a single lock can be held on an OPFS
+           file. We have no way of checking whether any _other_ db
+           connection has a lock except by trying to obtain and (on
+           success) release a sync-handle for it, but doing so would
+           involve an inherent race condition. For the time being,
+           pending a better solution, we simply report whether the
+           given pFile is open.
+
+           Update 2024-06-12: based on forum discussions, this
+           function now always sets pOut to 0 (false):
+
+           https://sqlite.org/forum/forumpost/a2f573b00cda1372
+        */
+        wasm.poke(pOut, 0, 'i32');
+        return 0;
+      },
+      xClose: function(pFile){
+        mTimeStart('xClose');
+        let rc = 0;
+        const f = __openFiles[pFile];
+        if(f){
+          delete __openFiles[pFile];
+          rc = opRun('xClose', pFile);
+          if(f.sq3File) f.sq3File.dispose();
+        }
+        mTimeEnd();
+        return rc;
+      },
+      xDeviceCharacteristics: function(pFile){
+        return capi.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
+      },
+      xFileControl: function(pFile, opId, pArg){
+        /*mTimeStart('xFileControl');
+          mTimeEnd();*/
+        return capi.SQLITE_NOTFOUND;
+      },
+      xFileSize: function(pFile,pSz64){
+        mTimeStart('xFileSize');
+        let rc = opRun('xFileSize', pFile);
+        if(0==rc){
+          try {
+            const sz = state.s11n.deserialize()[0];
+            wasm.poke(pSz64, sz, 'i64');
+          }catch(e){
+            error("Unexpected error reading xFileSize() result:",e);
+            rc = state.sq3Codes.SQLITE_IOERR;
+          }
+        }
+        mTimeEnd();
+        return rc;
+      },
+      xLock: function(pFile,lockType){
+        mTimeStart('xLock');
+        const f = __openFiles[pFile];
+        let rc = 0;
+        /* All OPFS locks are exclusive locks. If xLock() has
+           previously succeeded, do nothing except record the lock
+           type. If no lock is active, have the async counterpart
+           lock the file. */
+        if( !f.lockType ) {
+          rc = opRun('xLock', pFile, lockType);
+          if( 0===rc ) f.lockType = lockType;
+        }else{
+          f.lockType = lockType;
+        }
+        mTimeEnd();
+        return rc;
+      },
+      xRead: function(pFile,pDest,n,offset64){
+        mTimeStart('xRead');
+        const f = __openFiles[pFile];
+        let rc;
+        try {
+          rc = opRun('xRead',pFile, n, Number(offset64));
+          if(0===rc || capi.SQLITE_IOERR_SHORT_READ===rc){
+            /**
+               Results get written to the SharedArrayBuffer f.sabView.
+               Because the heap is _not_ a SharedArrayBuffer, we have
+               to copy the results. TypedArray.set() seems to be the
+               fastest way to copy this. */
+            wasm.heap8u().set(f.sabView.subarray(0, n), pDest);
+          }
+        }catch(e){
+          error("xRead(",arguments,") failed:",e,f);
+          rc = capi.SQLITE_IOERR_READ;
+        }
+        mTimeEnd();
+        return rc;
+      },
+      xSync: function(pFile,flags){
+        mTimeStart('xSync');
+        ++metrics.xSync.count;
+        const rc = opRun('xSync', pFile, flags);
+        mTimeEnd();
+        return rc;
+      },
+      xTruncate: function(pFile,sz64){
+        mTimeStart('xTruncate');
+        const rc = opRun('xTruncate', pFile, Number(sz64));
+        mTimeEnd();
+        return rc;
+      },
+      xUnlock: function(pFile,lockType){
+        mTimeStart('xUnlock');
+        const f = __openFiles[pFile];
+        let rc = 0;
+        if( capi.SQLITE_LOCK_NONE === lockType
+          && f.lockType ){
+          rc = opRun('xUnlock', pFile, lockType);
+        }
+        if( 0===rc ) f.lockType = lockType;
+        mTimeEnd();
+        return rc;
+      },
+      xWrite: function(pFile,pSrc,n,offset64){
+        mTimeStart('xWrite');
+        const f = __openFiles[pFile];
+        let rc;
+        try {
+          f.sabView.set(wasm.heap8u().subarray(pSrc, pSrc+n));
+          rc = opRun('xWrite', pFile, n, Number(offset64));
+        }catch(e){
+          error("xWrite(",arguments,") failed:",e,f);
+          rc = capi.SQLITE_IOERR_WRITE;
+        }
+        mTimeEnd();
+        return rc;
+      }
+    }/*ioSyncWrappers*/;
+
+    /**
+       Impls for the sqlite3_vfs methods. Maintenance reminder: members
+       are in alphabetical order to simplify finding them.
+    */
+    const vfsSyncWrappers = {
+      xAccess: function(pVfs,zName,flags,pOut){
+        mTimeStart('xAccess');
+        const rc = opRun('xAccess', wasm.cstrToJs(zName));
+        wasm.poke( pOut, (rc ? 0 : 1), 'i32' );
+        mTimeEnd();
+        return 0;
+      },
+      xCurrentTime: function(pVfs,pOut){
+        /* If it turns out that we need to adjust for timezone, see:
+           https://stackoverflow.com/a/11760121/1458521 */
+        wasm.poke(pOut, 2440587.5 + (new Date().getTime()/86400000),
+                  'double');
+        return 0;
+      },
+      xCurrentTimeInt64: function(pVfs,pOut){
+        wasm.poke(pOut, (2440587.5 * 86400000) + new Date().getTime(),
+                  'i64');
+        return 0;
+      },
+      xDelete: function(pVfs, zName, doSyncDir){
+        mTimeStart('xDelete');
+        const rc = opRun('xDelete', wasm.cstrToJs(zName), doSyncDir, false);
+        mTimeEnd();
+        return rc;
+      },
+      xFullPathname: function(pVfs,zName,nOut,pOut){
+        /* Until/unless we have some notion of "current dir"
+           in OPFS, simply copy zName to pOut... */
+        const i = wasm.cstrncpy(pOut, zName, nOut);
+        return i<nOut ? 0 : capi.SQLITE_CANTOPEN
+        /*CANTOPEN is required by the docs but SQLITE_RANGE would be a closer match*/;
+      },
+      xGetLastError: function(pVfs,nOut,pOut){
+        /* TODO: store exception.message values from the async
+           partner in a dedicated SharedArrayBuffer, noting that we'd have
+           to encode them... TextEncoder can do that for us. */
+        warn("OPFS xGetLastError() has nothing sensible to return.");
+        return 0;
+      },
+      //xSleep is optionally defined below
+      xOpen: function f(pVfs, zName, pFile, flags, pOutFlags){
+        mTimeStart('xOpen');
+        let opfsFlags = 0;
+        if(0===zName){
+          zName = randomFilename();
+        }else if(wasm.isPtr(zName)){
+          if(capi.sqlite3_uri_boolean(zName, "opfs-unlock-asap", 0)){
+            /* -----------------------^^^^^ MUST pass the untranslated
+               C-string here. */
+            opfsFlags |= state.opfsFlags.OPFS_UNLOCK_ASAP;
+          }
+          if(capi.sqlite3_uri_boolean(zName, "delete-before-open", 0)){
+            opfsFlags |= state.opfsFlags.OPFS_UNLINK_BEFORE_OPEN;
+          }
+          zName = wasm.cstrToJs(zName);
+          //warn("xOpen zName =",zName, "opfsFlags =",opfsFlags);
+        }
+        const fh = Object.create(null);
+        fh.fid = pFile;
+        fh.filename = zName;
+        fh.sab = new SharedArrayBuffer(state.fileBufferSize);
+        fh.flags = flags;
+        fh.readOnly = !(sqlite3.SQLITE_OPEN_CREATE & flags)
+          && !!(flags & capi.SQLITE_OPEN_READONLY);
+        const rc = opRun('xOpen', pFile, zName, flags, opfsFlags);
+        if(!rc){
+          /* Recall that sqlite3_vfs::xClose() will be called, even on
+             error, unless pFile->pMethods is NULL. */
+          if(fh.readOnly){
+            wasm.poke(pOutFlags, capi.SQLITE_OPEN_READONLY, 'i32');
+          }
+          __openFiles[pFile] = fh;
+          fh.sabView = state.sabFileBufView;
+          fh.sq3File = new sqlite3_file(pFile);
+          fh.sq3File.$pMethods = opfsIoMethods.pointer;
+          fh.lockType = capi.SQLITE_LOCK_NONE;
+        }
+        mTimeEnd();
+        return rc;
+      }/*xOpen()*/
+    }/*vfsSyncWrappers*/;
+
+    if(dVfs){
+      opfsVfs.$xRandomness = dVfs.$xRandomness;
+      opfsVfs.$xSleep = dVfs.$xSleep;
+    }
+    if(!opfsVfs.$xRandomness){
+      /* If the default VFS has no xRandomness(), add a basic JS impl... */
+      vfsSyncWrappers.xRandomness = function(pVfs, nOut, pOut){
+        const heap = wasm.heap8u();
+        let i = 0;
+        for(; i < nOut; ++i) heap[pOut + i] = (Math.random()*255000) & 0xFF;
+        return i;
+      };
+    }
+    if(!opfsVfs.$xSleep){
+      /* If we can inherit an xSleep() impl from the default VFS then
+         assume it's sane and use it, otherwise install a JS-based
+         one. */
+      vfsSyncWrappers.xSleep = function(pVfs,ms){
+        Atomics.wait(state.sabOPView, state.opIds.xSleep, 0, ms);
+        return 0;
+      };
+    }
+
+    /**
+       Expects an OPFS file path. It gets resolved, such that ".."
+       components are properly expanded, and returned. If the 2nd arg
+       is true, the result is returned as an array of path elements,
+       else an absolute path string is returned.
+    */
+    opfsUtil.getResolvedPath = function(filename,splitIt){
+      const p = new URL(filename, "file://irrelevant").pathname;
+      return splitIt ? p.split('/').filter((v)=>!!v) : p;
+    };
+
+    /**
+       Takes the absolute path to a filesystem element. Returns an
+       array of [handleOfContainingDir, filename]. If the 2nd argument
+       is truthy then each directory element leading to the file is
+       created along the way. Throws if any creation or resolution
+       fails.
+    */
+    opfsUtil.getDirForFilename = async function f(absFilename, createDirs = false){
+      const path = opfsUtil.getResolvedPath(absFilename, true);
+      const filename = path.pop();
+      let dh = opfsUtil.rootDirectory;
+      for(const dirName of path){
+        if(dirName){
+          dh = await dh.getDirectoryHandle(dirName, {create: !!createDirs});
+        }
+      }
+      return [dh, filename];
+    };
+
+    /**
+       Creates the given directory name, recursively, in
+       the OPFS filesystem. Returns true if it succeeds or the
+       directory already exists, else false.
+    */
+    opfsUtil.mkdir = async function(absDirName){
+      try {
+        await opfsUtil.getDirForFilename(absDirName+"/filepart", true);
+        return true;
+      }catch(e){
+        //sqlite3.config.warn("mkdir(",absDirName,") failed:",e);
+        return false;
+      }
+    };
+    /**
+       Checks whether the given OPFS filesystem entry exists,
+       returning true if it does, false if it doesn't or if an
+       exception is intercepted while trying to make the
+       determination.
+    */
+    opfsUtil.entryExists = async function(fsEntryName){
+      try {
+        const [dh, fn] = await opfsUtil.getDirForFilename(fsEntryName);
+        await dh.getFileHandle(fn);
+        return true;
+      }catch(e){
+        return false;
+      }
+    };
+
+    /**
+       Generates a random ASCII string, intended for use as a
+       temporary file name. Its argument is the length of the string,
+       defaulting to 16.
+    */
+    opfsUtil.randomFilename = randomFilename;
+
+    /**
+       Returns a promise which resolves to an object which represents
+       all files and directories in the OPFS tree. The top-most object
+       has two properties: `dirs` is an array of directory entries
+       (described below) and `files` is a list of file names for all
+       files in that directory.
+
+       Traversal starts at sqlite3.opfs.rootDirectory.
+
+       Each `dirs` entry is an object in this form:
+
+       ```
+       { name: directoryName,
+         dirs: [...subdirs],
+         files: [...file names]
+       }
+       ```
+
+       The `files` and `subdirs` entries are always set but may be
+       empty arrays.
+
+       The returned object has the same structure but its `name` is
+       an empty string. All returned objects are created with
+       Object.create(null), so have no prototype.
+
+       Design note: the entries do not contain more information,
+       e.g. file sizes, because getting such info is not only
+       expensive but is subject to locking-related errors.
+    */
+    opfsUtil.treeList = async function(){
+      const doDir = async function callee(dirHandle,tgt){
+        tgt.name = dirHandle.name;
+        tgt.dirs = [];
+        tgt.files = [];
+        for await (const handle of dirHandle.values()){
+          if('directory' === handle.kind){
+            const subDir = Object.create(null);
+            tgt.dirs.push(subDir);
+            await callee(handle, subDir);
+          }else{
+            tgt.files.push(handle.name);
+          }
+        }
+      };
+      const root = Object.create(null);
+      await doDir(opfsUtil.rootDirectory, root);
+      return root;
+    };
+
+    /**
+       Irrevocably deletes _all_ files in the current origin's OPFS.
+       Obviously, this must be used with great caution. It may throw
+       an exception if removal of anything fails (e.g. a file is
+       locked), but the precise conditions under which the underlying
+       APIs will throw are not documented (so we cannot tell you what
+       they are).
+    */
+    opfsUtil.rmfr = async function(){
+      const dir = opfsUtil.rootDirectory, opt = {recurse: true};
+      for await (const handle of dir.values()){
+        dir.removeEntry(handle.name, opt);
+      }
+    };
+
+    /**
+       Deletes the given OPFS filesystem entry.  As this environment
+       has no notion of "current directory", the given name must be an
+       absolute path. If the 2nd argument is truthy, deletion is
+       recursive (use with caution!).
+
+       The returned Promise resolves to true if the deletion was
+       successful, else false (but...). The OPFS API reports the
+       reason for the failure only in human-readable form, not
+       exceptions which can be type-checked to determine the
+       failure. Because of that...
+
+       If the final argument is truthy then this function will
+       propagate any exception on error, rather than returning false.
+    */
+    opfsUtil.unlink = async function(fsEntryName, recursive = false,
+                                     throwOnError = false){
+      try {
+        const [hDir, filenamePart] =
+              await opfsUtil.getDirForFilename(fsEntryName, false);
+        await hDir.removeEntry(filenamePart, {recursive});
+        return true;
+      }catch(e){
+        if(throwOnError){
+          throw new Error("unlink(",arguments[0],") failed: "+e.message,{
+            cause: e
+          });
+        }
+        return false;
+      }
+    };
+
+    /**
+       Traverses the OPFS filesystem, calling a callback for each
+       entry.  The argument may be either a callback function or an
+       options object with any of the following properties:
+
+       - `callback`: function which gets called for each filesystem
+         entry.  It gets passed 3 arguments: 1) the
+         FileSystemFileHandle or FileSystemDirectoryHandle of each
+         entry (noting that both are instanceof FileSystemHandle). 2)
+         the FileSystemDirectoryHandle of the parent directory. 3) the
+         current depth level, with 0 being at the top of the tree
+         relative to the starting directory. If the callback returns a
+         literal false, as opposed to any other falsy value, traversal
+         stops without an error. Any exceptions it throws are
+         propagated. Results are undefined if the callback manipulate
+         the filesystem (e.g. removing or adding entries) because the
+         how OPFS iterators behave in the face of such changes is
+         undocumented.
+
+       - `recursive` [bool=true]: specifies whether to recurse into
+         subdirectories or not. Whether recursion is depth-first or
+         breadth-first is unspecified!
+
+       - `directory` [FileSystemDirectoryEntry=sqlite3.opfs.rootDirectory]
+         specifies the starting directory.
+
+       If this function is passed a function, it is assumed to be the
+       callback.
+
+       Returns a promise because it has to (by virtue of being async)
+       but that promise has no specific meaning: the traversal it
+       performs is synchronous. The promise must be used to catch any
+       exceptions propagated by the callback, however.
+    */
+    opfsUtil.traverse = async function(opt){
+      const defaultOpt = {
+        recursive: true,
+        directory: opfsUtil.rootDirectory
+      };
+      if('function'===typeof opt){
+        opt = {callback:opt};
+      }
+      opt = Object.assign(defaultOpt, opt||{});
+      const doDir = async function callee(dirHandle, depth){
+        for await (const handle of dirHandle.values()){
+          if(false === opt.callback(handle, dirHandle, depth)) return false;
+          else if(opt.recursive && 'directory' === handle.kind){
+            if(false === await callee(handle, depth + 1)) break;
+          }
+        }
+      };
+      doDir(opt.directory, 0);
+    };
+
+    /**
+       impl of importDb() when it's given a function as its second
+       argument.
+    */
+    const importDbChunked = async function(filename, callback){
+      const [hDir, fnamePart] = await opfsUtil.getDirForFilename(filename, true);
+      const hFile = await hDir.getFileHandle(fnamePart, {create:true});
+      let sah = await hFile.createSyncAccessHandle();
+      let nWrote = 0, chunk, checkedHeader = false, err = false;
+      try{
+        sah.truncate(0);
+        while( undefined !== (chunk = await callback()) ){
+          if(chunk instanceof ArrayBuffer) chunk = new Uint8Array(chunk);
+          if( 0===nWrote && chunk.byteLength>=15 ){
+            util.affirmDbHeader(chunk);
+            checkedHeader = true;
+          }
+          sah.write(chunk, {at: nWrote});
+          nWrote += chunk.byteLength;
+        }
+        if( nWrote < 512 || 0!==nWrote % 512 ){
+          toss("Input size",nWrote,"is not correct for an SQLite database.");
+        }
+        if( !checkedHeader ){
+          const header = new Uint8Array(20);
+          sah.read( header, {at: 0} );
+          util.affirmDbHeader( header );
+        }
+        sah.write(new Uint8Array([1,1]), {at: 18}/*force db out of WAL mode*/);
+        return nWrote;
+      }catch(e){
+        await sah.close();
+        sah = undefined;
+        await hDir.removeEntry( fnamePart ).catch(()=>{});
+        throw e;
+      }finally {
+        if( sah ) await sah.close();
+      }
+    };
+
+    /**
+       Asynchronously imports the given bytes (a byte array or
+       ArrayBuffer) into the given database file.
+
+       Results are undefined if the given db name refers to an opened
+       db.
+
+       If passed a function for its second argument, its behaviour
+       changes: imports its data in chunks fed to it by the given
+       callback function. It calls the callback (which may be async)
+       repeatedly, expecting either a Uint8Array or ArrayBuffer (to
+       denote new input) or undefined (to denote EOF). For so long as
+       the callback continues to return non-undefined, it will append
+       incoming data to the given VFS-hosted database file. When
+       called this way, the resolved value of the returned Promise is
+       the number of bytes written to the target file.
+
+       It very specifically requires the input to be an SQLite3
+       database and throws if that's not the case.  It does so in
+       order to prevent this function from taking on a larger scope
+       than it is specifically intended to. i.e. we do not want it to
+       become a convenience for importing arbitrary files into OPFS.
+
+       This routine rewrites the database header bytes in the output
+       file (not the input array) to force disabling of WAL mode.
+
+       On error this throws and the state of the input file is
+       undefined (it depends on where the exception was triggered).
+
+       On success, resolves to the number of bytes written.
+    */
+    opfsUtil.importDb = async function(filename, bytes){
+      if( bytes instanceof Function ){
+        return importDbChunked(filename, bytes);
+      }
+      if(bytes instanceof ArrayBuffer) bytes = new Uint8Array(bytes);
+      util.affirmIsDb(bytes);
+      const n = bytes.byteLength;
+      const [hDir, fnamePart] = await opfsUtil.getDirForFilename(filename, true);
+      let sah, err, nWrote = 0;
+      try {
+        const hFile = await hDir.getFileHandle(fnamePart, {create:true});
+        sah = await hFile.createSyncAccessHandle();
+        sah.truncate(0);
+        nWrote = sah.write(bytes, {at: 0});
+        if(nWrote != n){
+          toss("Expected to write "+n+" bytes but wrote "+nWrote+".");
+        }
+        sah.write(new Uint8Array([1,1]), {at: 18}) /* force db out of WAL mode */;
+        return nWrote;
+      }catch(e){
+        if( sah ){ await sah.close(); sah = undefined; }
+        await hDir.removeEntry( fnamePart ).catch(()=>{});
+        throw e;
+      }finally{
+        if( sah ) await sah.close();
+      }
+    };
+
+    if(sqlite3.oo1){
+      const OpfsDb = function(...args){
+        const opt = sqlite3.oo1.DB.dbCtorHelper.normalizeArgs(...args);
+        opt.vfs = opfsVfs.$zName;
+        sqlite3.oo1.DB.dbCtorHelper.call(this, opt);
+      };
+      OpfsDb.prototype = Object.create(sqlite3.oo1.DB.prototype);
+      sqlite3.oo1.OpfsDb = OpfsDb;
+      OpfsDb.importDb = opfsUtil.importDb;
+      sqlite3.oo1.DB.dbCtorHelper.setVfsPostOpenCallback(
+        opfsVfs.pointer,
+        function(oo1Db, sqlite3){
+          /* Set a relatively high default busy-timeout handler to
+             help OPFS dbs deal with multi-tab/multi-worker
+             contention. */
+          sqlite3.capi.sqlite3_busy_timeout(oo1Db, 10000);
+        }
+      );
+    }/*extend sqlite3.oo1*/
+
+    const sanityCheck = function(){
+      const scope = wasm.scopedAllocPush();
+      const sq3File = new sqlite3_file();
+      try{
+        const fid = sq3File.pointer;
+        const openFlags = capi.SQLITE_OPEN_CREATE
+              | capi.SQLITE_OPEN_READWRITE
+        //| capi.SQLITE_OPEN_DELETEONCLOSE
+              | capi.SQLITE_OPEN_MAIN_DB;
+        const pOut = wasm.scopedAlloc(8);
+        const dbFile = "/sanity/check/file"+randomFilename(8);
+        const zDbFile = wasm.scopedAllocCString(dbFile);
+        let rc;
+        state.s11n.serialize("This is ä string.");
+        rc = state.s11n.deserialize();
+        log("deserialize() says:",rc);
+        if("This is ä string."!==rc[0]) toss("String d13n error.");
+        vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut);
+        rc = wasm.peek(pOut,'i32');
+        log("xAccess(",dbFile,") exists ?=",rc);
+        rc = vfsSyncWrappers.xOpen(opfsVfs.pointer, zDbFile,
+                                   fid, openFlags, pOut);
+        log("open rc =",rc,"state.sabOPView[xOpen] =",
+            state.sabOPView[state.opIds.xOpen]);
+        if(0!==rc){
+          error("open failed with code",rc);
+          return;
+        }
+        vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut);
+        rc = wasm.peek(pOut,'i32');
+        if(!rc) toss("xAccess() failed to detect file.");
+        rc = ioSyncWrappers.xSync(sq3File.pointer, 0);
+        if(rc) toss('sync failed w/ rc',rc);
+        rc = ioSyncWrappers.xTruncate(sq3File.pointer, 1024);
+        if(rc) toss('truncate failed w/ rc',rc);
+        wasm.poke(pOut,0,'i64');
+        rc = ioSyncWrappers.xFileSize(sq3File.pointer, pOut);
+        if(rc) toss('xFileSize failed w/ rc',rc);
+        log("xFileSize says:",wasm.peek(pOut, 'i64'));
+        rc = ioSyncWrappers.xWrite(sq3File.pointer, zDbFile, 10, 1);
+        if(rc) toss("xWrite() failed!");
+        const readBuf = wasm.scopedAlloc(16);
+        rc = ioSyncWrappers.xRead(sq3File.pointer, readBuf, 6, 2);
+        wasm.poke(readBuf+6,0);
+        let jRead = wasm.cstrToJs(readBuf);
+        log("xRead() got:",jRead);
+        if("sanity"!==jRead) toss("Unexpected xRead() value.");
+        if(vfsSyncWrappers.xSleep){
+          log("xSleep()ing before close()ing...");
+          vfsSyncWrappers.xSleep(opfsVfs.pointer,2000);
+          log("waking up from xSleep()");
+        }
+        rc = ioSyncWrappers.xClose(fid);
+        log("xClose rc =",rc,"sabOPView =",state.sabOPView);
+        log("Deleting file:",dbFile);
+        vfsSyncWrappers.xDelete(opfsVfs.pointer, zDbFile, 0x1234);
+        vfsSyncWrappers.xAccess(opfsVfs.pointer, zDbFile, 0, pOut);
+        rc = wasm.peek(pOut,'i32');
+        if(rc) toss("Expecting 0 from xAccess(",dbFile,") after xDelete().");
+        warn("End of OPFS sanity checks.");
+      }finally{
+        sq3File.dispose();
+        wasm.scopedAllocPop(scope);
+      }
+    }/*sanityCheck()*/;
+
+    W.onmessage = function({data}){
+      //log("Worker.onmessage:",data);
+      switch(data.type){
+          case 'opfs-unavailable':
+            /* Async proxy has determined that OPFS is unavailable. There's
+               nothing more for us to do here. */
+            promiseReject(new Error(data.payload.join(' ')));
+            break;
+          case 'opfs-async-loaded':
+            /* Arrives as soon as the asyc proxy finishes loading.
+               Pass our config and shared state on to the async
+               worker. */
+            W.postMessage({type: 'opfs-async-init',args: state});
+            break;
+          case 'opfs-async-inited': {
+            /* Indicates that the async partner has received the 'init'
+               and has finished initializing, so the real work can
+               begin... */
+            if(true===promiseWasRejected){
+              break /* promise was already rejected via timer */;
+            }
+            try {
+              sqlite3.vfs.installVfs({
+                io: {struct: opfsIoMethods, methods: ioSyncWrappers},
+                vfs: {struct: opfsVfs, methods: vfsSyncWrappers}
+              });
+              state.sabOPView = new Int32Array(state.sabOP);
+              state.sabFileBufView = new Uint8Array(state.sabIO, 0, state.fileBufferSize);
+              state.sabS11nView = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize);
+              initS11n();
+              if(options.sanityChecks){
+                warn("Running sanity checks because of opfs-sanity-check URL arg...");
+                sanityCheck();
+              }
+              if(thisThreadHasOPFS()){
+                navigator.storage.getDirectory().then((d)=>{
+                  W.onerror = W._originalOnError;
+                  delete W._originalOnError;
+                  sqlite3.opfs = opfsUtil;
+                  opfsUtil.rootDirectory = d;
+                  log("End of OPFS sqlite3_vfs setup.", opfsVfs);
+                  promiseResolve();
+                }).catch(promiseReject);
+              }else{
+                promiseResolve();
+              }
+            }catch(e){
+              error(e);
+              promiseReject(e);
+            }
+            break;
+          }
+          default: {
+            const errMsg = (
+              "Unexpected message from the OPFS async worker: " +
+              JSON.stringify(data)
+            );
+            error(errMsg);
+            promiseReject(new Error(errMsg));
+            break;
+          }
+      }/*switch(data.type)*/
+    }/*W.onmessage()*/;
+  })/*thePromise*/;
+  return thePromise;
+}/*installOpfsVfs()*/;
+installOpfsVfs.defaultProxyUri =
+  "sqlite3-opfs-async-proxy.js";
+globalThis.sqlite3ApiBootstrap.initializersAsync.push(async (sqlite3)=>{
+  try{
+    let proxyJs = installOpfsVfs.defaultProxyUri;
+    if(sqlite3.scriptInfo.sqlite3Dir){
+      installOpfsVfs.defaultProxyUri =
+        sqlite3.scriptInfo.sqlite3Dir + proxyJs;
+      //sqlite3.config.warn("installOpfsVfs.defaultProxyUri =",installOpfsVfs.defaultProxyUri);
+    }
+    return installOpfsVfs().catch((e)=>{
+      sqlite3.config.warn("Ignoring inability to install OPFS sqlite3_vfs:",e.message);
+    });
+  }catch(e){
+    sqlite3.config.error("installOpfsVfs() exception:",e);
+    return Promise.reject(e);
+  }
+});
+}/*sqlite3ApiBootstrap.initializers.push()*/);
+//#else
+/* The OPFS VFS parts are elided from builds targeting node.js. */
+//#endif target=node

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js

@@ -0,0 +1,346 @@
+//#ifnot omit-oo1
+/*
+  2022-08-24
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This file implements a Promise-based proxy for the sqlite3 Worker
+  API #1. It is intended to be included either from the main thread or
+  a Worker, but only if (A) the environment supports nested Workers
+  and (B) it's _not_ a Worker which loads the sqlite3 WASM/JS
+  module. This file's features will load that module and provide a
+  slightly simpler client-side interface than the slightly-lower-level
+  Worker API does.
+
+  This script necessarily exposes one global symbol, but clients may
+  freely `delete` that symbol after calling it.
+*/
+'use strict';
+/**
+   Configures an sqlite3 Worker API #1 Worker such that it can be
+   manipulated via a Promise-based interface and returns a factory
+   function which returns Promises for communicating with the worker.
+   This proxy has an _almost_ identical interface to the normal
+   worker API, with any exceptions documented below.
+
+   It requires a configuration object with the following properties:
+
+   - `worker` (required): a Worker instance which loads
+   `sqlite3-worker1.js` or a functional equivalent. Note that the
+   promiser factory replaces the worker.onmessage property. This
+   config option may alternately be a function, in which case this
+   function re-assigns this property with the result of calling that
+   function, enabling delayed instantiation of a Worker.
+
+   - `onready` (optional, but...): this callback is called with no
+   arguments when the worker fires its initial
+   'sqlite3-api'/'worker1-ready' message, which it does when
+   sqlite3.initWorker1API() completes its initialization. This is the
+   simplest way to tell the worker to kick off work at the earliest
+   opportunity, and the only way to know when the worker module has
+   completed loading. The irony of using a callback for this, instead
+   of returning a promise from sqlite3Worker1Promiser() is not lost on
+   the developers: see sqlite3Worker1Promiser.v2() which uses a
+   Promise instead.
+
+   - `onunhandled` (optional): a callback which gets passed the
+   message event object for any worker.onmessage() events which
+   are not handled by this proxy. Ideally that "should" never
+   happen, as this proxy aims to handle all known message types.
+
+   - `generateMessageId` (optional): a function which, when passed an
+   about-to-be-posted message object, generates a _unique_ message ID
+   for the message, which this API then assigns as the messageId
+   property of the message. It _must_ generate unique IDs on each call
+   so that dispatching can work. If not defined, a default generator
+   is used (which should be sufficient for most or all cases).
+
+   - `debug` (optional): a console.debug()-style function for logging
+   information about messages.
+
+   This function returns a stateful factory function with the
+   following interfaces:
+
+   - Promise function(messageType, messageArgs)
+   - Promise function({message object})
+
+   The first form expects the "type" and "args" values for a Worker
+   message. The second expects an object in the form {type:...,
+   args:...}  plus any other properties the client cares to set. This
+   function will always set the `messageId` property on the object,
+   even if it's already set, and will set the `dbId` property to the
+   current database ID if it is _not_ set in the message object.
+
+   The function throws on error.
+
+   The function installs a temporary message listener, posts a
+   message to the configured Worker, and handles the message's
+   response via the temporary message listener. The then() callback
+   of the returned Promise is passed the `message.data` property from
+   the resulting message, i.e. the payload from the worker, stripped
+   of the lower-level event state which the onmessage() handler
+   receives.
+
+   Example usage:
+
+   ```
+   const config = {...};
+   const sq3Promiser = sqlite3Worker1Promiser(config);
+   sq3Promiser('open', {filename:"/foo.db"}).then(function(msg){
+     console.log("open response",msg); // => {type:'open', result: {filename:'/foo.db'}, ...}
+   });
+   sq3Promiser({type:'close'}).then((msg)=>{
+     console.log("close response",msg); // => {type:'close', result: {filename:'/foo.db'}, ...}
+   });
+   ```
+
+   Differences from Worker API #1:
+
+   - exec's {callback: STRING} option does not work via this
+   interface (it triggers an exception), but {callback: function}
+   does and works exactly like the STRING form does in the Worker:
+   the callback is called one time for each row of the result set,
+   passed the same worker message format as the worker API emits:
+
+     {type:typeString,
+      row:VALUE,
+      rowNumber:1-based-#,
+      columnNames: array}
+
+   Where `typeString` is an internally-synthesized message type string
+   used temporarily for worker message dispatching. It can be ignored
+   by all client code except that which tests this API. The `row`
+   property contains the row result in the form implied by the
+   `rowMode` option (defaulting to `'array'`). The `rowNumber` is a
+   1-based integer value incremented by 1 on each call into the
+   callback.
+
+   At the end of the result set, the same event is fired with
+   (row=undefined, rowNumber=null) to indicate that
+   the end of the result set has been reached. Note that the rows
+   arrive via worker-posted messages, with all the implications
+   of that.
+
+   Notable shortcomings:
+
+   - This API was not designed with ES6 modules in mind. Neither Firefox
+     nor Safari support, as of March 2023, the {type:"module"} flag to the
+     Worker constructor, so that particular usage is not something we're going
+     to target for the time being:
+
+     https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker
+*/
+globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfig){
+  // Inspired by: https://stackoverflow.com/a/52439530
+  if(1===arguments.length && 'function'===typeof arguments[0]){
+    const f = config;
+    config = Object.assign(Object.create(null), callee.defaultConfig);
+    config.onready = f;
+  }else{
+    config = Object.assign(Object.create(null), callee.defaultConfig, config);
+  }
+  const handlerMap = Object.create(null);
+  const noop = function(){};
+  const err = config.onerror
+        || noop /* config.onerror is intentionally undocumented
+                   pending finding a less ambiguous name */;
+  const debug = config.debug || noop;
+  const idTypeMap = config.generateMessageId ? undefined : Object.create(null);
+  const genMsgId = config.generateMessageId || function(msg){
+    return msg.type+'#'+(idTypeMap[msg.type] = (idTypeMap[msg.type]||0) + 1);
+  };
+  const toss = (...args)=>{throw new Error(args.join(' '))};
+  if(!config.worker) config.worker = callee.defaultConfig.worker;
+  if('function'===typeof config.worker) config.worker = config.worker();
+  let dbId;
+  let promiserFunc;
+  config.worker.onmessage = function(ev){
+    ev = ev.data;
+    debug('worker1.onmessage',ev);
+    let msgHandler = handlerMap[ev.messageId];
+    if(!msgHandler){
+      if(ev && 'sqlite3-api'===ev.type && 'worker1-ready'===ev.result) {
+        /*fired one time when the Worker1 API initializes*/
+        if(config.onready) config.onready(promiserFunc);
+        return;
+      }
+      msgHandler = handlerMap[ev.type] /* check for exec per-row callback */;
+      if(msgHandler && msgHandler.onrow){
+        msgHandler.onrow(ev);
+        return;
+      }
+      if(config.onunhandled) config.onunhandled(arguments[0]);
+      else err("sqlite3Worker1Promiser() unhandled worker message:",ev);
+      return;
+    }
+    delete handlerMap[ev.messageId];
+    switch(ev.type){
+        case 'error':
+          msgHandler.reject(ev);
+          return;
+        case 'open':
+          if(!dbId) dbId = ev.dbId;
+          break;
+        case 'close':
+          if(ev.dbId===dbId) dbId = undefined;
+          break;
+        default:
+          break;
+    }
+    try {msgHandler.resolve(ev)}
+    catch(e){msgHandler.reject(e)}
+  }/*worker.onmessage()*/;
+  return promiserFunc = function(/*(msgType, msgArgs) || (msgEnvelope)*/){
+    let msg;
+    if(1===arguments.length){
+      msg = arguments[0];
+    }else if(2===arguments.length){
+      msg = Object.create(null);
+      msg.type = arguments[0];
+      msg.args = arguments[1];
+      msg.dbId = msg.args.dbId;
+    }else{
+      toss("Invalid arguments for sqlite3Worker1Promiser()-created factory.");
+    }
+    if(!msg.dbId && msg.type!=='open') msg.dbId = dbId;
+    msg.messageId = genMsgId(msg);
+    msg.departureTime = performance.now();
+    const proxy = Object.create(null);
+    proxy.message = msg;
+    let rowCallbackId /* message handler ID for exec on-row callback proxy */;
+    if('exec'===msg.type && msg.args){
+      if('function'===typeof msg.args.callback){
+        rowCallbackId = msg.messageId+':row';
+        proxy.onrow = msg.args.callback;
+        msg.args.callback = rowCallbackId;
+        handlerMap[rowCallbackId] = proxy;
+      }else if('string' === typeof msg.args.callback){
+        toss("exec callback may not be a string when using the Promise interface.");
+        /**
+           Design note: the reason for this limitation is that this
+           API takes over worker.onmessage() and the client has no way
+           of adding their own message-type handlers to it. Per-row
+           callbacks are implemented as short-lived message.type
+           mappings for worker.onmessage().
+
+           We "could" work around this by providing a new
+           config.fallbackMessageHandler (or some such) which contains
+           a map of event type names to callbacks. Seems like overkill
+           for now, seeing as the client can pass callback functions
+           to this interface (whereas the string-form "callback" is
+           needed for the over-the-Worker interface).
+        */
+      }
+    }
+    //debug("requestWork", msg);
+    let p = new Promise(function(resolve, reject){
+      proxy.resolve = resolve;
+      proxy.reject = reject;
+      handlerMap[msg.messageId] = proxy;
+      debug("Posting",msg.type,"message to Worker dbId="+(dbId||'default')+':',msg);
+      config.worker.postMessage(msg);
+    });
+    if(rowCallbackId) p = p.finally(()=>delete handlerMap[rowCallbackId]);
+    return p;
+  };
+}/*sqlite3Worker1Promiser()*/;
+
+globalThis.sqlite3Worker1Promiser.defaultConfig = {
+  worker: function(){
+//#if target=es6-module
+    return new Worker(new URL("sqlite3-worker1-bundler-friendly.mjs", import.meta.url),{
+      type: 'module'
+    });
+//#else
+    let theJs = "sqlite3-worker1.js";
+    if(this.currentScript){
+      const src = this.currentScript.src.split('/');
+      src.pop();
+      theJs = src.join('/')+'/' + theJs;
+      //sqlite3.config.warn("promiser currentScript, theJs =",this.currentScript,theJs);
+    }else if(globalThis.location){
+      //sqlite3.config.warn("promiser globalThis.location =",globalThis.location);
+      const urlParams = new URL(globalThis.location.href).searchParams;
+      if(urlParams.has('sqlite3.dir')){
+        theJs = urlParams.get('sqlite3.dir') + '/' + theJs;
+      }
+    }
+    return new Worker(theJs + globalThis.location.search);
+//#endif
+  }
+//#ifnot target=es6-module
+  .bind({
+    currentScript: globalThis?.document?.currentScript
+  })
+//#endif
+  ,
+  onerror: (...args)=>console.error('worker1 promiser error',...args)
+}/*defaultConfig*/;
+
+/**
+   sqlite3Worker1Promiser.v2(), added in 3.46, works identically to
+   sqlite3Worker1Promiser() except that it returns a Promise instead
+   of relying an an onready callback in the config object. The Promise
+   resolves to the same factory function which
+   sqlite3Worker1Promiser() returns.
+
+   If config is-a function or is an object which contains an onready
+   function, that function is replaced by a proxy which will resolve
+   after calling the original function and will reject if that
+   function throws.
+*/
+sqlite3Worker1Promiser.v2 = function(config){
+  let oldFunc;
+  if( 'function' == typeof config ){
+    oldFunc = config;
+    config = {};
+  }else if('function'===typeof config?.onready){
+    oldFunc = config.onready;
+    delete config.onready;
+  }
+  const promiseProxy = Object.create(null);
+  config = Object.assign((config || Object.create(null)),{
+    onready: async function(func){
+      try {
+        if( oldFunc ) await oldFunc(func);
+        promiseProxy.resolve(func);
+      }
+      catch(e){promiseProxy.reject(e)}
+    }
+  });
+  const p = new Promise(function(resolve,reject){
+    promiseProxy.resolve = resolve;
+    promiseProxy.reject = reject;
+  });
+  try{
+    this.original(config);
+  }catch(e){
+    promiseProxy.reject(e);
+  }
+  return p;
+}.bind({
+   /* We do this because clients are
+      recommended to delete globalThis.sqlite3Worker1Promiser. */
+  original: sqlite3Worker1Promiser
+});
+
+//#if target=es6-module
+/**
+  When built as a module, we export sqlite3Worker1Promiser.v2()
+  instead of sqlite3Worker1Promise() because (A) its interface is more
+  conventional for ESM usage and (B) the ESM option export option for
+  this API did not exist until v2 was created, so there's no backwards
+  incompatibility.
+*/
+export default sqlite3Worker1Promiser.v2;
+//#endif /* target=es6-module */
+//#else
+/* Built with the omit-oo1 flag. */
+//#endif ifnot omit-oo1

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/common/SqliteTestUtil.js

@@ -0,0 +1,235 @@
+/*
+  2022-05-22
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This file contains bootstrapping code used by various test scripts
+  which live in this file's directory.
+*/
+'use strict';
+(function(self){
+  /* querySelectorAll() proxy */
+  const EAll = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelectorAll(arguments[arguments.length-1]);
+  };
+  /* querySelector() proxy */
+  const E = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelector(arguments[arguments.length-1]);
+  };
+
+  /**
+     Helpers for writing sqlite3-specific tests.
+  */
+  self.SqliteTestUtil = {
+    /** Running total of the number of tests run via
+        this API. */
+    counter: 0,
+    /**
+       If expr is a function, it is called and its result
+       is returned, coerced to a bool, else expr, coerced to
+       a bool, is returned.
+    */
+    toBool: function(expr){
+      return (expr instanceof Function) ? !!expr() : !!expr;
+    },
+    /** abort() if expr is false. If expr is a function, it
+        is called and its result is evaluated.
+    */
+    assert: function f(expr, msg){
+      if(!f._){
+        f._ = ('undefined'===typeof abort
+               ? (msg)=>{throw new Error(msg)}
+               : abort);
+      }
+      ++this.counter;
+      if(!this.toBool(expr)){
+        f._(msg || "Assertion failed.");
+      }
+      return this;
+    },
+    /** Identical to assert() but throws instead of calling
+        abort(). */
+    affirm: function(expr, msg){
+      ++this.counter;
+      if(!this.toBool(expr)) throw new Error(msg || "Affirmation failed.");
+      return this;
+    },
+    /** Calls f() and squelches any exception it throws. If it
+        does not throw, this function throws. */
+    mustThrow: function(f, msg){
+      ++this.counter;
+      let err;
+      try{ f(); } catch(e){err=e;}
+      if(!err) throw new Error(msg || "Expected exception.");
+      return this;
+    },
+    /**
+       Works like mustThrow() but expects filter to be a regex,
+       function, or string to match/filter the resulting exception
+       against. If f() does not throw, this test fails and an Error is
+       thrown. If filter is a regex, the test passes if
+       filter.test(error.message) passes. If it's a function, the test
+       passes if filter(error) returns truthy. If it's a string, the
+       test passes if the filter matches the exception message
+       precisely. In all other cases the test fails, throwing an
+       Error.
+
+       If it throws, msg is used as the error report unless it's falsy,
+       in which case a default is used.
+    */
+    mustThrowMatching: function(f, filter, msg){
+      ++this.counter;
+      let err;
+      try{ f(); } catch(e){err=e;}
+      if(!err) throw new Error(msg || "Expected exception.");
+      let pass = false;
+      if(filter instanceof RegExp) pass = filter.test(err.message);
+      else if(filter instanceof Function) pass = filter(err);
+      else if('string' === typeof filter) pass = (err.message === filter);
+      if(!pass){
+        throw new Error(msg || ("Filter rejected this exception: "+err.message));
+      }
+      return this;
+    },
+    /** Throws if expr is truthy or expr is a function and expr()
+        returns truthy. */
+    throwIf: function(expr, msg){
+      ++this.counter;
+      if(this.toBool(expr)) throw new Error(msg || "throwIf() failed");
+      return this;
+    },
+    /** Throws if expr is falsy or expr is a function and expr()
+        returns falsy. */
+    throwUnless: function(expr, msg){
+      ++this.counter;
+      if(!this.toBool(expr)) throw new Error(msg || "throwUnless() failed");
+      return this;
+    },
+
+    /**
+       Parses window.location.search-style string into an object
+       containing key/value pairs of URL arguments (already
+       urldecoded). The object is created using Object.create(null),
+       so contains only parsed-out properties and has no prototype
+       (and thus no inherited properties).
+
+       If the str argument is not passed (arguments.length==0) then
+       window.location.search.substring(1) is used by default. If
+       neither str is passed in nor window exists then false is returned.
+
+       On success it returns an Object containing the key/value pairs
+       parsed from the string. Keys which have no value are treated
+       has having the boolean true value.
+
+       Pedantic licensing note: this code has appeared in other source
+       trees, but was originally written by the same person who pasted
+       it into those trees.
+    */
+    processUrlArgs: function(str) {
+      if( 0 === arguments.length ) {
+        if( ('undefined' === typeof window) ||
+            !window.location ||
+            !window.location.search )  return false;
+        else str = (''+window.location.search).substring(1);
+      }
+      if( ! str ) return false;
+      str = (''+str).split(/#/,2)[0]; // remove #... to avoid it being added as part of the last value.
+      const args = Object.create(null);
+      const sp = str.split(/&+/);
+      const rx = /^([^=]+)(=(.+))?/;
+      var i, m;
+      for( i in sp ) {
+        m = rx.exec( sp[i] );
+        if( ! m ) continue;
+        args[decodeURIComponent(m[1])] = (m[3] ? decodeURIComponent(m[3]) : true);
+      }
+      return args;
+    }
+  };
+
+  /**
+     This is a module object for use with the emscripten-installed
+     sqlite3InitModule() factory function.
+  */
+  self.sqlite3TestModule = {
+    /**
+       Array of functions to call after Emscripten has initialized the
+       wasm module. Each gets passed the Emscripten module object
+       (which is _this_ object).
+    */
+    postRun: [
+      /* function(theModule){...} */
+    ],
+    //onRuntimeInitialized: function(){},
+    /* Proxy for C-side stdout output. */
+    print: (...args)=>{console.log(...args)},
+    /* Proxy for C-side stderr output. */
+    printErr: (...args)=>{console.error(...args)},
+    /**
+       Called by the Emscripten module init bits to report loading
+       progress. It gets passed an empty argument when loading is done
+       (after onRuntimeInitialized() and any this.postRun callbacks
+       have been run).
+    */
+    setStatus: function f(text){
+      if(!f.last){
+        f.last = { text: '', step: 0 };
+        f.ui = {
+          status: E('#module-status'),
+          progress: E('#module-progress'),
+          spinner: E('#module-spinner')
+        };
+      }
+      if(text === f.last.text) return;
+      f.last.text = text;
+      if(f.ui.progress){
+        f.ui.progress.value = f.last.step;
+        f.ui.progress.max = f.last.step + 1;
+      }
+      ++f.last.step;
+      if(text) {
+        f.ui.status.classList.remove('hidden');
+        f.ui.status.innerText = text;
+      }else{
+        if(f.ui.progress){
+          f.ui.progress.remove();
+          f.ui.spinner.remove();
+          delete f.ui.progress;
+          delete f.ui.spinner;
+        }
+        f.ui.status.classList.add('hidden');
+      }
+    },
+    /**
+       Config options used by the Emscripten-dependent initialization
+       which happens via this.initSqlite3(). This object gets
+       (indirectly) passed to sqlite3ApiBootstrap() to configure the
+       sqlite3 API.
+    */
+    sqlite3ApiConfig: {
+      wasmfsOpfsDir: "/opfs"
+    },
+    /**
+       Intended to be called by apps which need to call the
+       Emscripten-installed sqlite3InitModule() routine. This function
+       temporarily installs this.sqlite3ApiConfig into the self
+       object, calls it sqlite3InitModule(), and removes
+       self.sqlite3ApiConfig after initialization is done. Returns the
+       promise from sqlite3InitModule(), and the next then() handler
+       will get the sqlite3 API object as its argument.
+    */
+    initSqlite3: function(){
+      self.sqlite3ApiConfig = this.sqlite3ApiConfig;
+      return self.sqlite3InitModule(this).finally(()=>delete self.sqlite3ApiConfig);
+    }
+  };
+})(self/*window or worker*/);

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/common/testing.css

@@ -0,0 +1,102 @@
+body {
+  display: flex;
+  flex-direction: column;
+  flex-wrap: wrap;
+}
+textarea {
+    font-family: monospace;
+}
+header {
+    font-size: 130%;
+    font-weight: bold;
+}
+.hidden, .initially-hidden {
+    position: absolute !important;
+    opacity: 0 !important;
+    pointer-events: none !important;
+    display: none !important;
+}
+fieldset.options {
+    font-size: 75%;
+}
+fieldset > legend {
+    padding: 0 0.5em;
+}
+span.labeled-input {
+    padding: 0.25em;
+    margin: 0.25em 0.5em;
+    border-radius: 0.25em;
+    white-space: nowrap;
+    background: #0002;
+}
+.center { text-align: center; }
+.error {
+    color: red;
+    background-color: yellow;
+}
+.strong { font-weight: 700 }
+.warning { color: firebrick; }
+.green { color: darkgreen; }
+.tests-pass { background-color: green; color: white }
+.tests-fail { background-color: red; color: yellow }
+.faded { opacity: 0.5; }
+.group-start {
+  color: blue;
+  background-color: skyblue;
+  font-weight: bold;
+  border-top: 1px dotted blue;
+  padding: 0.5em;
+  margin-top: 0.5em;
+}
+.group-end {
+  padding: 0.5em;
+  margin-bottom: 0.25em;
+  /*border-bottom: 1px dotted blue;*/
+}
+.group-end.green {
+  background: lightgreen;
+  border-bottom: 1px dotted green;
+}
+.one-test-line, .skipping-group {
+  margin-left: 3em;
+}
+.skipping-test, .skipping-group {
+  padding: 0.25em 0.5em;
+  background-color: #ffff73;
+}
+.skipping-test {
+  margin-left: 6em;
+}
+.one-test-summary {
+  margin-left: 6em;
+}
+.full-test-summary {
+  padding-bottom: 0.5em;
+  padding-top: 0.5em;
+  border-top: 1px solid black;
+}
+.input-wrapper {
+  white-space: nowrap;
+  display: flex;
+  align-items: center;
+}
+#test-output {
+  border: 1px inset;
+  border-radius: 0.25em;
+  padding: 0.25em;
+  /*max-height: 30em;*/
+  overflow: auto;
+  white-space: break-spaces;
+  display: flex; flex-direction: column;
+  font-family: monospace;
+}
+#test-output.reverse {
+  flex-direction: column-reverse;
+}
+label[for] { cursor: pointer }
+
+h1 {
+  border-radius: 0.25em;
+  padding: 0.15em 0.25em;
+}
+h1:first-of-type {margin: 0 0 0.5em 0;}

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/fiddle/fiddle.js

@@ -0,0 +1,822 @@
+/*
+  2022-05-20
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This is the main entry point for the sqlite3 fiddle app. It sets up the
+  various UI bits, loads a Worker for the db connection, and manages the
+  communication between the UI and worker.
+*/
+(function(){
+  'use strict';
+  /* Recall that the 'self' symbol, except where locally
+     overwritten, refers to the global window or worker object. */
+
+  const storage = (function(NS/*namespace object in which to store this module*/){
+    /* Pedantic licensing note: this code originated in the Fossil SCM
+       source tree, where it has a different license, but the person who
+       ported it into sqlite is the same one who wrote it for fossil. */
+    'use strict';
+    NS = NS||{};
+
+    /**
+       This module provides a basic wrapper around localStorage
+       or sessionStorage or a dummy proxy object if neither
+       of those are available.
+    */
+    const tryStorage = function f(obj){
+      if(!f.key) f.key = 'storage.access.check';
+      try{
+        obj.setItem(f.key, 'f');
+        const x = obj.getItem(f.key);
+        obj.removeItem(f.key);
+        if(x!=='f') throw new Error(f.key+" failed")
+        return obj;
+      }catch(e){
+        return undefined;
+      }
+    };
+
+    /** Internal storage impl for this module. */
+    const $storage =
+          tryStorage(window.localStorage)
+          || tryStorage(window.sessionStorage)
+          || tryStorage({
+            // A basic dummy xyzStorage stand-in
+            $$$:{},
+            setItem: function(k,v){this.$$$[k]=v},
+            getItem: function(k){
+              return this.$$$.hasOwnProperty(k) ? this.$$$[k] : undefined;
+            },
+            removeItem: function(k){delete this.$$$[k]},
+            clear: function(){this.$$$={}}
+          });
+
+    /**
+       For the dummy storage we need to differentiate between
+       $storage and its real property storage for hasOwnProperty()
+       to work properly...
+    */
+    const $storageHolder = $storage.hasOwnProperty('$$$') ? $storage.$$$ : $storage;
+
+    /**
+       A prefix which gets internally applied to all storage module
+       property keys so that localStorage and sessionStorage across the
+       same browser profile instance do not "leak" across multiple apps
+       being hosted by the same origin server. Such cross-polination is
+       still there but, with this key prefix applied, it won't be
+       immediately visible via the storage API.
+
+       With this in place we can justify using localStorage instead of
+       sessionStorage.
+
+       One implication of using localStorage and sessionStorage is that
+       their scope (the same "origin" and client application/profile)
+       allows multiple apps on the same origin to use the same
+       storage. Thus /appA/foo could then see changes made via
+       /appB/foo. The data do not cross user- or browser boundaries,
+       though, so it "might" arguably be called a
+       feature. storageKeyPrefix was added so that we can sandbox that
+       state for each separate app which shares an origin.
+
+       See: https://fossil-scm.org/forum/forumpost/4afc4d34de
+
+       Sidebar: it might seem odd to provide a key prefix and stick all
+       properties in the topmost level of the storage object. We do that
+       because adding a layer of object to sandbox each app would mean
+       (de)serializing that whole tree on every storage property change.
+       e.g. instead of storageObject.projectName.foo we have
+       storageObject[storageKeyPrefix+'foo']. That's soley for
+       efficiency's sake (in terms of battery life and
+       environment-internal storage-level effort).
+    */
+    const storageKeyPrefix = (
+      $storageHolder===$storage/*localStorage or sessionStorage*/
+        ? (
+          (NS.config ?
+           (NS.config.projectCode || NS.config.projectName
+            || NS.config.shortProjectName)
+           : false)
+            || window.location.pathname
+        )+'::' : (
+          '' /* transient storage */
+        )
+    );
+
+    /**
+       A proxy for localStorage or sessionStorage or a
+       page-instance-local proxy, if neither one is availble.
+
+       Which exact storage implementation is uses is unspecified, and
+       apps must not rely on it.
+    */
+    NS.storage = {
+      storageKeyPrefix: storageKeyPrefix,
+      /** Sets the storage key k to value v, implicitly converting
+          it to a string. */
+      set: (k,v)=>$storage.setItem(storageKeyPrefix+k,v),
+      /** Sets storage key k to JSON.stringify(v). */
+      setJSON: (k,v)=>$storage.setItem(storageKeyPrefix+k,JSON.stringify(v)),
+      /** Returns the value for the given storage key, or
+          dflt if the key is not found in the storage. */
+      get: (k,dflt)=>$storageHolder.hasOwnProperty(
+        storageKeyPrefix+k
+      ) ? $storage.getItem(storageKeyPrefix+k) : dflt,
+      /** Returns true if the given key has a value of "true".  If the
+          key is not found, it returns true if the boolean value of dflt
+          is "true". (Remember that JS persistent storage values are all
+          strings.) */
+      getBool: function(k,dflt){
+        return 'true'===this.get(k,''+(!!dflt));
+      },
+      /** Returns the JSON.parse()'d value of the given
+          storage key's value, or dflt is the key is not
+          found or JSON.parse() fails. */
+      getJSON: function f(k,dflt){
+        try {
+          const x = this.get(k,f);
+          return x===f ? dflt : JSON.parse(x);
+        }
+        catch(e){return dflt}
+      },
+      /** Returns true if the storage contains the given key,
+          else false. */
+      contains: (k)=>$storageHolder.hasOwnProperty(storageKeyPrefix+k),
+      /** Removes the given key from the storage. Returns this. */
+      remove: function(k){
+        $storage.removeItem(storageKeyPrefix+k);
+        return this;
+      },
+      /** Clears ALL keys from the storage. Returns this. */
+      clear: function(){
+        this.keys().forEach((k)=>$storage.removeItem(/*w/o prefix*/k));
+        return this;
+      },
+      /** Returns an array of all keys currently in the storage. */
+      keys: ()=>Object.keys($storageHolder).filter((v)=>(v||'').startsWith(storageKeyPrefix)),
+      /** Returns true if this storage is transient (only available
+          until the page is reloaded), indicating that fileStorage
+          and sessionStorage are unavailable. */
+      isTransient: ()=>$storageHolder!==$storage,
+      /** Returns a symbolic name for the current storage mechanism. */
+      storageImplName: function(){
+        if($storage===window.localStorage) return 'localStorage';
+        else if($storage===window.sessionStorage) return 'sessionStorage';
+        else return 'transient';
+      },
+
+      /**
+         Returns a brief help text string for the currently-selected
+         storage type.
+      */
+      storageHelpDescription: function(){
+        return {
+          localStorage: "Browser-local persistent storage with an "+
+            "unspecified long-term lifetime (survives closing the browser, "+
+            "but maybe not a browser upgrade).",
+          sessionStorage: "Storage local to this browser tab, "+
+            "lost if this tab is closed.",
+          "transient": "Transient storage local to this invocation of this page."
+        }[this.storageImplName()];
+      }
+    };
+    return NS.storage;
+  })({})/*storage API setup*/;
+
+
+  /** Name of the stored copy of SqliteFiddle.config. */
+  const configStorageKey = 'sqlite3-fiddle-config';
+
+  /**
+     The SqliteFiddle object is intended to be the primary
+     app-level object for the main-thread side of the sqlite
+     fiddle application. It uses a worker thread to load the
+     sqlite WASM module and communicate with it.
+  */
+  const SF/*local convenience alias*/
+        = window.SqliteFiddle/*canonical name*/ = {
+          /* Config options. */
+          config: {
+            /* If true, SqliteFiddle.echo() will auto-scroll the
+               output widget to the bottom when it receives output,
+               else it won't. */
+            autoScrollOutput: true,
+            /* If true, the output area will be cleared before each
+               command is run, else it will not. */
+            autoClearOutput: false,
+            /* If true, SqliteFiddle.echo() will echo its output to
+               the console, in addition to its normal output widget.
+               That slows it down but is useful for testing. */
+            echoToConsole: false,
+            /* If true, display input/output areas side-by-side. */
+            sideBySide: true,
+            /* If true, swap positions of the input/output areas. */
+            swapInOut: false
+          },
+          /**
+             Emits the given text, followed by a line break, to the
+             output widget.  If given more than one argument, they are
+             join()'d together with a space between each. As a special
+             case, if passed a single array, that array is used in place
+             of the arguments array (this is to facilitate receiving
+             lists of arguments via worker events).
+          */
+          echo: function f(text) {
+            /* Maintenance reminder: we currently require/expect a textarea
+               output element. It might be nice to extend this to behave
+               differently if the output element is a non-textarea element,
+               in which case it would need to append the given text as a TEXT
+               node and add a line break. */
+            if(!f._){
+              f._ = document.getElementById('output');
+              f._.value = ''; // clear browser cache
+            }
+            if(arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
+            else if(1===arguments.length && Array.isArray(text)) text = text.join(' ');
+            // These replacements are necessary if you render to raw HTML
+            //text = text.replace(/&/g, "&");
+            //text = text.replace(/</g, "&lt;");
+            //text = text.replace(/>/g, "&gt;");
+            //text = text.replace('\n', '<br>', 'g');
+            if(null===text){/*special case: clear output*/
+              f._.value = '';
+              return;
+            }else if(this.echo._clearPending){
+              delete this.echo._clearPending;
+              f._.value = '';
+            }
+            if(this.config.echoToConsole) console.log(text);
+            if(this.jqTerm) this.jqTerm.echo(text);
+            f._.value += text + "\n";
+            if(this.config.autoScrollOutput){
+              f._.scrollTop = f._.scrollHeight;
+            }
+          },
+          _msgMap: {},
+          /** Adds a worker message handler for messages of the given
+              type. */
+          addMsgHandler: function f(type,callback){
+            if(Array.isArray(type)){
+              type.forEach((t)=>this.addMsgHandler(t, callback));
+              return this;
+            }
+            (this._msgMap.hasOwnProperty(type)
+             ? this._msgMap[type]
+             : (this._msgMap[type] = [])).push(callback);
+            return this;
+          },
+          /** Given a worker message, runs all handlers for msg.type. */
+          runMsgHandlers: function(msg){
+            const list = (this._msgMap.hasOwnProperty(msg.type)
+                          ? this._msgMap[msg.type] : false);
+            if(!list){
+              console.warn("No handlers found for message type:",msg);
+              return false;
+            }
+            //console.debug("runMsgHandlers",msg);
+            list.forEach((f)=>f(msg));
+            return true;
+          },
+          /** Removes all message handlers for the given message type. */
+          clearMsgHandlers: function(type){
+            delete this._msgMap[type];
+            return this;
+          },
+          /* Posts a message in the form {type, data} to the db worker. Returns this. */
+          wMsg: function(type,data,transferables){
+            this.worker.postMessage({type, data}, transferables || []);
+            return this;
+          },
+          /**
+             Prompts for confirmation and, if accepted, deletes
+             all content and tables in the (transient) database.
+          */
+          resetDb: function(){
+            if(window.confirm("Really destroy all content and tables "
+                              +"in the (transient) db?")){
+              this.wMsg('db-reset');
+            }
+            return this;
+          },
+          /** Stores this object's config in the browser's storage. */
+          storeConfig: function(){
+            storage.setJSON(configStorageKey,this.config);
+          }
+        };
+
+  if(1){ /* Restore SF.config */
+    const storedConfig = storage.getJSON(configStorageKey);
+    if(storedConfig){
+      /* Copy all properties to SF.config which are currently in
+         storedConfig. We don't bother copying any other
+         properties: those have been removed from the app in the
+         meantime. */
+      Object.keys(SF.config).forEach(function(k){
+        if(storedConfig.hasOwnProperty(k)){
+          SF.config[k] = storedConfig[k];
+        }
+      });
+    }
+  }
+
+  SF.worker = new Worker('fiddle-worker.js'+self.location.search);
+  SF.worker.onmessage = (ev)=>SF.runMsgHandlers(ev.data);
+  SF.addMsgHandler(['stdout', 'stderr'], (ev)=>SF.echo(ev.data));
+
+  /* querySelectorAll() proxy */
+  const EAll = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelectorAll(arguments[arguments.length-1]);
+  };
+  /* querySelector() proxy */
+  const E = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelector(arguments[arguments.length-1]);
+  };
+
+  /** Handles status updates from the Emscripten Module object. */
+  SF.addMsgHandler('module', function f(ev){
+    ev = ev.data;
+    if('status'!==ev.type){
+      console.warn("Unexpected module-type message:",ev);
+      return;
+    }
+    if(!f.ui){
+      f.ui = {
+        status: E('#module-status'),
+        progress: E('#module-progress'),
+        spinner: E('#module-spinner')
+      };
+    }
+    const msg = ev.data;
+    if(f.ui.progres){
+      progress.value = msg.step;
+      progress.max = msg.step + 1/*we don't know how many steps to expect*/;
+    }
+    if(1==msg.step){
+      f.ui.progress.classList.remove('hidden');
+      f.ui.spinner.classList.remove('hidden');
+    }
+    if(msg.text){
+      f.ui.status.classList.remove('hidden');
+      f.ui.status.innerText = msg.text;
+    }else{
+      if(f.ui.progress){
+        f.ui.progress.remove();
+        f.ui.spinner.remove();
+        delete f.ui.progress;
+        delete f.ui.spinner;
+      }
+      f.ui.status.classList.add('hidden');
+      /* The module can post messages about fatal problems,
+         e.g. an exit() being triggered or assertion failure,
+         after the last "load" message has arrived, so
+         leave f.ui.status and message listener intact. */
+    }
+  });
+
+  /**
+     The 'fiddle-ready' event is fired (with no payload) when the
+     wasm module has finished loading. Interestingly, that happens
+     _before_ the final module:status event */
+  SF.addMsgHandler('fiddle-ready', function(){
+    SF.clearMsgHandlers('fiddle-ready');
+    self.onSFLoaded();
+  });
+
+  /**
+     Performs all app initialization which must wait until after the
+     worker module is loaded. This function removes itself when it's
+     called.
+  */
+  self.onSFLoaded = function(){
+    delete this.onSFLoaded;
+    // Unhide all elements which start out hidden
+    EAll('.initially-hidden').forEach((e)=>e.classList.remove('initially-hidden'));
+    E('#btn-reset').addEventListener('click',()=>SF.resetDb());
+    const taInput = E('#input');
+    const btnClearIn = E('#btn-clear');
+    const selectExamples = E('#select-examples');
+    btnClearIn.addEventListener('click',function(){
+      taInput.value = '';
+      selectExamples.selectedIndex = 0;
+    },false);
+    // Ctrl-enter and shift-enter both run the current SQL.
+    taInput.addEventListener('keydown',function(ev){
+      if((ev.ctrlKey || ev.shiftKey) && 13 === ev.keyCode){
+        ev.preventDefault();
+        ev.stopPropagation();
+        btnShellExec.click();
+      }
+    }, false);
+    const taOutput = E('#output');
+    const btnClearOut = E('#btn-clear-output');
+    btnClearOut.addEventListener('click',function(){
+      taOutput.value = '';
+      if(SF.jqTerm) SF.jqTerm.clear();
+    },false);
+    const btnShellExec = E('#btn-shell-exec');
+    btnShellExec.addEventListener('click',function(ev){
+      let sql;
+      ev.preventDefault();
+      if(taInput.selectionStart<taInput.selectionEnd){
+        sql = taInput.value.substring(taInput.selectionStart,taInput.selectionEnd).trim();
+      }else{
+        sql = taInput.value.trim();
+      }
+      if(sql) SF.dbExec(sql);
+    },false);
+
+    const btnInterrupt = E("#btn-interrupt");
+    //btnInterrupt.classList.add('hidden');
+    /** To be called immediately before work is sent to the
+        worker. Updates some UI elements. The 'working'/'end'
+        event will apply the inverse, undoing the bits this
+        function does. This impl is not in the 'working'/'start'
+        event handler because that event is given to us
+        asynchronously _after_ we need to have performed this
+        work.
+    */
+    const preStartWork = function f(){
+      if(!f._){
+        const title = E('title');
+        f._ = {
+          btnLabel: btnShellExec.innerText,
+          pageTitle: title,
+          pageTitleOrig: title.innerText
+        };
+      }
+      f._.pageTitle.innerText = "[working...] "+f._.pageTitleOrig;
+      btnShellExec.setAttribute('disabled','disabled');
+      btnInterrupt.removeAttribute('disabled','disabled');
+    };
+
+    /* Sends the given text to the db module to evaluate as if it
+       had been entered in the sqlite3 CLI shell. If it's null or
+       empty, this is a no-op. */
+    SF.dbExec = function f(sql){
+      if(null!==sql && this.config.autoClearOutput){
+        this.echo._clearPending = true;
+      }
+      preStartWork();
+      this.wMsg('shellExec',sql);
+    };
+
+    SF.addMsgHandler('working',function f(ev){
+      switch(ev.data){
+          case 'start': /* See notes in preStartWork(). */; return;
+          case 'end':
+            preStartWork._.pageTitle.innerText = preStartWork._.pageTitleOrig;
+            btnShellExec.innerText = preStartWork._.btnLabel;
+            btnShellExec.removeAttribute('disabled');
+            btnInterrupt.setAttribute('disabled','disabled');
+            return;
+      }
+      console.warn("Unhandled 'working' event:",ev.data);
+    });
+
+    /* For each checkbox with data-csstgt, set up a handler which
+       toggles the given CSS class on the element matching
+       E(data-csstgt). */
+    EAll('input[type=checkbox][data-csstgt]')
+      .forEach(function(e){
+        const tgt = E(e.dataset.csstgt);
+        const cssClass = e.dataset.cssclass || 'error';
+        e.checked = tgt.classList.contains(cssClass);
+        e.addEventListener('change', function(){
+          tgt.classList[
+            this.checked ? 'add' : 'remove'
+          ](cssClass)
+        }, false);
+      });
+    /* For each checkbox with data-config=X, set up a binding to
+       SF.config[X]. These must be set up AFTER data-csstgt
+       checkboxes so that those two states can be synced properly. */
+    EAll('input[type=checkbox][data-config]')
+      .forEach(function(e){
+        const confVal = !!SF.config[e.dataset.config];
+        if(e.checked !== confVal){
+          /* Ensure that data-csstgt mappings (if any) get
+             synced properly. */
+          e.checked = confVal;
+          e.dispatchEvent(new Event('change'));
+        }
+        e.addEventListener('change', function(){
+          SF.config[this.dataset.config] = this.checked;
+          SF.storeConfig();
+        }, false);
+      });
+    /* For each button with data-cmd=X, map a click handler which
+       calls SF.dbExec(X). */
+    const cmdClick = function(){SF.dbExec(this.dataset.cmd);};
+    EAll('button[data-cmd]').forEach(
+      e => e.addEventListener('click', cmdClick, false)
+    );
+
+    btnInterrupt.addEventListener('click',function(){
+      SF.wMsg('interrupt');
+    });
+
+    /** Initiate a download of the db. */
+    const btnExport = E('#btn-export');
+    const eLoadDb = E('#load-db');
+    const btnLoadDb = E('#btn-load-db');
+    btnLoadDb.addEventListener('click', ()=>eLoadDb.click());
+    /**
+       Enables (if passed true) or disables all UI elements which
+       "might," if timed "just right," interfere with an
+       in-progress db import/export/exec operation.
+    */
+    const enableMutatingElements = function f(enable){
+      if(!f._elems){
+        f._elems = [
+          /* UI elements to disable while import/export are
+             running. Normally the export is fast enough
+             that this won't matter, but we really don't
+             want to be reading (from outside of sqlite) the
+             db when the user taps btnShellExec. */
+          btnShellExec, btnExport, eLoadDb
+        ];
+      }
+      f._elems.forEach( enable
+                        ? (e)=>e.removeAttribute('disabled')
+                        : (e)=>e.setAttribute('disabled','disabled') );
+    };
+    btnExport.addEventListener('click',function(){
+      enableMutatingElements(false);
+      SF.wMsg('db-export');
+    });
+    SF.addMsgHandler('db-export', function(ev){
+      enableMutatingElements(true);
+      ev = ev.data;
+      if(ev.error){
+        SF.echo("Export failed:",ev.error);
+        return;
+      }
+      const blob = new Blob([ev.buffer],
+                            {type:"application/x-sqlite3"});
+      const a = document.createElement('a');
+      document.body.appendChild(a);
+      a.href = window.URL.createObjectURL(blob);
+      a.download = ev.filename;
+      a.addEventListener('click',function(){
+        setTimeout(function(){
+          SF.echo("Exported (possibly auto-downloaded):",ev.filename);
+          window.URL.revokeObjectURL(a.href);
+          a.remove();
+        },500);
+      });
+      a.click();
+    });
+    /**
+       Handle load/import of an external db file.
+    */
+    eLoadDb.addEventListener('change',function(){
+      const f = this.files[0];
+      const r = new FileReader();
+      const status = {loaded: 0, total: 0};
+      enableMutatingElements(false);
+      r.addEventListener('loadstart', function(){
+        SF.echo("Loading",f.name,"...");
+      });
+      r.addEventListener('progress', function(ev){
+        SF.echo("Loading progress:",ev.loaded,"of",ev.total,"bytes.");
+      });
+      const that = this;
+      r.addEventListener('load', function(){
+        enableMutatingElements(true);
+        SF.echo("Loaded",f.name+". Opening db...");
+        SF.wMsg('open',{
+          filename: f.name,
+          buffer: this.result
+        }, [this.result]);
+      });
+      r.addEventListener('error',function(){
+        enableMutatingElements(true);
+        SF.echo("Loading",f.name,"failed for unknown reasons.");
+      });
+      r.addEventListener('abort',function(){
+        enableMutatingElements(true);
+        SF.echo("Cancelled loading of",f.name+".");
+      });
+      r.readAsArrayBuffer(f);
+    });
+
+    EAll('fieldset.collapsible').forEach(function(fs){
+      const btnToggle = E(fs,'legend > .fieldset-toggle'),
+            content = EAll(fs,':scope > div');
+      btnToggle.addEventListener('click', function(){
+        fs.classList.toggle('collapsed');
+        content.forEach((d)=>d.classList.toggle('hidden'));
+      }, false);
+    });
+
+    /**
+       Given a DOM element, this routine measures its "effective
+       height", which is the bounding top/bottom range of this element
+       and all of its children, recursively. For some DOM structure
+       cases, a parent may have a reported height of 0 even though
+       children have non-0 sizes.
+
+       Returns 0 if !e or if the element really has no height.
+    */
+    const effectiveHeight = function f(e){
+      if(!e) return 0;
+      if(!f.measure){
+        f.measure = function callee(e, depth){
+          if(!e) return;
+          const m = e.getBoundingClientRect();
+          if(0===depth){
+            callee.top = m.top;
+            callee.bottom = m.bottom;
+          }else{
+            callee.top = m.top ? Math.min(callee.top, m.top) : callee.top;
+            callee.bottom = Math.max(callee.bottom, m.bottom);
+          }
+          Array.prototype.forEach.call(e.children,(e)=>callee(e,depth+1));
+          if(0===depth){
+            //console.debug("measure() height:",e.className, callee.top, callee.bottom, (callee.bottom - callee.top));
+            f.extra += callee.bottom - callee.top;
+          }
+          return f.extra;
+        };
+      }
+      f.extra = 0;
+      f.measure(e,0);
+      return f.extra;
+    };
+
+    /**
+       Returns a function, that, as long as it continues to be invoked,
+       will not be triggered. The function will be called after it stops
+       being called for N milliseconds. If `immediate` is passed, call
+       the callback immediately and hinder future invocations until at
+       least the given time has passed.
+
+       If passed only 1 argument, or passed a falsy 2nd argument,
+       the default wait time set in this function's $defaultDelay
+       property is used.
+
+       Source: underscore.js, by way of https://davidwalsh.name/javascript-debounce-function
+    */
+    const debounce = function f(func, wait, immediate) {
+      var timeout;
+      if(!wait) wait = f.$defaultDelay;
+      return function() {
+        const context = this, args = Array.prototype.slice.call(arguments);
+        const later = function() {
+          timeout = undefined;
+          if(!immediate) func.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if(callNow) func.apply(context, args);
+      };
+    };
+    debounce.$defaultDelay = 500 /*arbitrary*/;
+
+    const ForceResizeKludge = (function(){
+      /* Workaround for Safari mayhem regarding use of vh CSS
+         units....  We cannot use vh units to set the main view
+         size because Safari chokes on that, so we calculate
+         that height here. Larger than ~95% is too big for
+         Firefox on Android, causing the input area to move
+         off-screen. */
+      const appViews = EAll('.app-view');
+      const elemsToCount = [
+        /* Elements which we need to always count in the
+           visible body size. */
+        E('body > header'),
+        E('body > footer')
+      ];
+      const resized = function f(){
+        if(f.$disabled) return;
+        const wh = window.innerHeight;
+        var ht;
+        var extra = 0;
+        elemsToCount.forEach((e)=>e ? extra += effectiveHeight(e) : false);
+        ht = wh - extra;
+        appViews.forEach(function(e){
+          e.style.height =
+            e.style.maxHeight = [
+              "calc(", (ht>=100 ? ht : 100), "px",
+              " - 2em"/*fudge value*/,")"
+              /* ^^^^ hypothetically not needed, but both
+                 Chrome/FF on Linux will force scrollbars on the
+                 body if this value is too small. */
+            ].join('');
+        });
+      };
+      resized.$disabled = true/*gets deleted when setup is finished*/;
+      window.addEventListener('resize', debounce(resized, 250), false);
+      return resized;
+    })();
+
+    /** Set up a selection list of examples */
+    (function(){
+      const xElem = E('#select-examples');
+      const examples = [
+        {name: "Help", sql: [
+          "-- ================================================\n",
+          "-- Use ctrl-enter or shift-enter to execute sqlite3\n",
+          "-- shell commands and SQL.\n",
+          "-- If a subset of the text is currently selected,\n",
+          "-- only that part is executed.\n",
+          "-- ================================================\n",
+          ".help\n"
+        ]},
+              //{name: "Timer on", sql: ".timer on"},
+              // ^^^ re-enable if emscripten re-enables getrusage()
+        {name: "Box Mode", sql: ".mode box"},
+        {name: "Setup table T", sql:[
+          ".nullvalue NULL\n",
+          "CREATE TABLE t(a,b);\n",
+          "INSERT INTO t(a,b) VALUES('abc',123),('def',456),(NULL,789),('ghi',012);\n",
+          "SELECT * FROM t;\n"
+        ]},
+        {name: "sqlite_schema", sql: "select * from sqlite_schema"},
+        {name: "Mandelbrot", sql:[
+          "WITH RECURSIVE",
+          "  xaxis(x) AS (VALUES(-2.0) UNION ALL SELECT x+0.05 FROM xaxis WHERE x<1.2),\n",
+          "  yaxis(y) AS (VALUES(-1.0) UNION ALL SELECT y+0.1 FROM yaxis WHERE y<1.0),\n",
+          "  m(iter, cx, cy, x, y) AS (\n",
+          "    SELECT 0, x, y, 0.0, 0.0 FROM xaxis, yaxis\n",
+          "    UNION ALL\n",
+          "    SELECT iter+1, cx, cy, x*x-y*y + cx, 2.0*x*y + cy FROM m \n",
+          "     WHERE (x*x + y*y) < 4.0 AND iter<28\n",
+          "  ),\n",
+          "  m2(iter, cx, cy) AS (\n",
+          "    SELECT max(iter), cx, cy FROM m GROUP BY cx, cy\n",
+          "  ),\n",
+          "  a(t) AS (\n",
+          "    SELECT group_concat( substr(' .+*#', 1+min(iter/7,4), 1), '') \n",
+          "    FROM m2 GROUP BY cy\n",
+          "  )\n",
+          "SELECT group_concat(rtrim(t),x'0a') as Mandelbrot FROM a;\n",
+        ]},
+        {name: "JSON pretty-print",
+         sql: "select json_pretty(json_object('ex',json('[52,3.14159]')))"
+        },
+        {name: "JSON pretty-print (with tabs)",
+         sql: "select json_pretty(json_object('ex',json('[52,3.14159]')),char(0x09))"
+        }
+      ];
+      const newOpt = function(lbl,val){
+        const o = document.createElement('option');
+        if(Array.isArray(val)) val = val.join('');
+        o.value = val;
+        if(!val) o.setAttribute('disabled',true);
+        o.appendChild(document.createTextNode(lbl));
+        xElem.appendChild(o);
+      };
+      newOpt("Examples (replaces input!)");
+      examples.forEach((o)=>newOpt(o.name, o.sql));
+      //xElem.setAttribute('disabled',true);
+      xElem.selectedIndex = 0;
+      xElem.addEventListener('change', function(){
+        taInput.value = '-- ' +
+          this.selectedOptions[0].innerText +
+          '\n' + this.value;
+        SF.dbExec(this.value);
+      });
+    })()/* example queries */;
+
+    //SF.echo(null/*clear any output generated by the init process*/);
+    if(window.jQuery && window.jQuery.terminal){
+      /* Set up the terminal-style view... */
+      const eTerm = window.jQuery('#view-terminal').empty();
+      SF.jqTerm = eTerm.terminal(SF.dbExec.bind(SF),{
+        prompt: 'sqlite> ',
+        greetings: false /* note that the docs incorrectly call this 'greeting' */
+      });
+      /* Set up a button to toggle the views... */
+      const head = E('header#titlebar');
+      const btnToggleView = document.createElement('button');
+      btnToggleView.appendChild(document.createTextNode("Toggle View"));
+      head.appendChild(btnToggleView);
+      btnToggleView.addEventListener('click',function f(){
+        EAll('.app-view').forEach(e=>e.classList.toggle('hidden'));
+        if(document.body.classList.toggle('terminal-mode')){
+          ForceResizeKludge();
+        }
+      }, false);
+      btnToggleView.click()/*default to terminal view*/;
+    }
+    SF.echo('This experimental app is provided in the hope that it',
+            'may prove interesting or useful but is not an officially',
+            'supported deliverable of the sqlite project. It is subject to',
+            'any number of changes or outright removal at any time.\n');
+    const urlParams = new URL(self.location.href).searchParams;
+    SF.dbExec(urlParams.get('sql') || null);
+    delete ForceResizeKludge.$disabled;
+    ForceResizeKludge();
+  }/*onSFLoaded()*/;
+})();

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/tests/opfs/concurrency/index.html

@@ -0,0 +1,52 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+    <link rel="stylesheet" href="../../../common/testing.css"/>
+    <title>sqlite3 OPFS Worker concurrency tester</title>
+    <style>
+      body { display: revert; }
+      body > * {}
+      #test-output {
+          font-family: monospace;
+      }
+    </style>
+  </head>
+  <body>
+    <h1></h1>
+    <p>
+      OPFS concurrency tester using multiple independent Workers.
+      Disclaimer: concurrency in OPFS is currently a pain point!
+    </p>
+    <p>
+      URL flags: pass a number of workers using
+      the <code>workers=N</code> URL flag. Set the time between each
+      workload with <code>interval=N</code> (milliseconds). Set the
+      number of worker iterations with <code>iterations=N</code>.
+      Enable OPFS VFS verbosity with <code>verbose=1-3</code> (output
+      goes to the dev console). Disable/enable "unlock ASAP" mode
+      (higher concurrency, lower speed) with <code>unlock-asap=0-1</code>.
+    </p>
+    <p>Achtung: if it does not start to do anything within a couple of
+      seconds, check the dev console: Chrome sometimes fails to load
+      the wasm module due to "cannot allocate WasmMemory." Closing and
+      re-opening the tab usually resolves it, but sometimes restarting
+      the browser is required.
+    </p>
+    <p>
+      Links for various testing options: <ul id='testlinks'></ul>
+    </p>
+    <div class='input-wrapper'>
+      <input type='checkbox' id='cb-log-reverse'>
+      <label for='cb-log-reverse'>Reverse log order?</label>
+    </div>
+    <div id='test-output'></div>
+    <script>(function(){
+      document.querySelector('h1').innerHTML =
+        document.querySelector('title').innerHTML;
+    })();</script>
+    <script src="test.js?sqlite3.dir=../../../jswasm"></script>
+  </body>
+</html>