firewall: introduce incomplete untested prototype

This doesn't support NDP yet, and some major things are still left to be
decided, but this is the beginning of something that can be debugged
into shape.

Signed-off-by: Odd Stranne <odd@mullvad.net>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Aleksandar Pesic <peske.nis@gmail.com>

1 files changed, 602 insertions, 0 deletions

diff --git a/service/firewall/types_windows_test.go b/service/firewall/types_windows_test.go
new file mode 100644
index 00000000..6ff6e09d
--- /dev/null
+++ b/service/firewall/types_windows_test.go
@@ -0,0 +1,602 @@
+/* SPDX-License-Identifier: MIT
+ *
+ * Copyright (C) 2019 WireGuard LLC. All Rights Reserved.
+ */
+
+package firewall
+
+import (
+	"testing"
+	"unsafe"
+)
+
+func TestWtFwpByteBlobSize(t *testing.T) {
+
+	const actualWtFwpByteBlobSize = unsafe.Sizeof(wtFwpByteBlob{})
+
+	if actualWtFwpByteBlobSize != wtFwpByteBlob_Size {
+		t.Errorf("Size of FwpByteBlob is %d, although %d is expected.", actualWtFwpByteBlobSize,
+			wtFwpByteBlob_Size)
+	}
+}
+
+func TestWtFwpByteBlobOffsets(t *testing.T) {
+
+	s := wtFwpByteBlob{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.data)) - sp
+
+	if offset != wtFwpByteBlob_data_Offset {
+		t.Errorf("FwpByteBlob.data offset is %d although %d is expected", offset, wtFwpByteBlob_data_Offset)
+		return
+	}
+}
+
+func TestWtFwpmAction0Size(t *testing.T) {
+
+	const actualWtFwpmAction0Size = unsafe.Sizeof(wtFwpmAction0{})
+
+	if actualWtFwpmAction0Size != wtFwpmAction0_Size {
+		t.Errorf("Size of wtFwpmAction0 is %d, although %d is expected.", actualWtFwpmAction0Size,
+			wtFwpmAction0_Size)
+	}
+}
+
+func TestWtFwpmAction0Offsets(t *testing.T) {
+
+	s := wtFwpmAction0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.filterType)) - sp
+
+	if offset != wtFwpmAction0_filterType_Offset {
+		t.Errorf("wtFwpmAction0.filterType offset is %d although %d is expected", offset,
+			wtFwpmAction0_filterType_Offset)
+		return
+	}
+}
+
+func TestWtFwpBitmapArray64Size(t *testing.T) {
+
+	const actualWtFwpBitmapArray64Size = unsafe.Sizeof(wtFwpBitmapArray64{})
+
+	if actualWtFwpBitmapArray64Size != wtFwpBitmapArray64_Size {
+		t.Errorf("Size of wtFwpBitmapArray64 is %d, although %d is expected.", actualWtFwpBitmapArray64Size,
+			wtFwpBitmapArray64_Size)
+	}
+}
+
+func TestWtFwpByteArray6Size(t *testing.T) {
+
+	const actualWtFwpByteArray6Size = unsafe.Sizeof(wtFwpByteArray6{})
+
+	if actualWtFwpByteArray6Size != wtFwpByteArray6_Size {
+		t.Errorf("Size of wtFwpByteArray6 is %d, although %d is expected.", actualWtFwpByteArray6Size,
+			wtFwpByteArray6_Size)
+	}
+}
+
+func TestWtFwpByteArray16Size(t *testing.T) {
+
+	const actualWtFwpByteArray16Size = unsafe.Sizeof(wtFwpByteArray16{})
+
+	if actualWtFwpByteArray16Size != wtFwpByteArray16_Size {
+		t.Errorf("Size of wtFwpByteArray16 is %d, although %d is expected.", actualWtFwpByteArray16Size,
+			wtFwpByteArray16_Size)
+	}
+}
+
+func TestWtFwpConditionValue0Size(t *testing.T) {
+
+	const actualWtFwpConditionValue0Size = unsafe.Sizeof(wtFwpConditionValue0{})
+
+	if actualWtFwpConditionValue0Size != wtFwpConditionValue0_Size {
+		t.Errorf("Size of wtFwpConditionValue0 is %d, although %d is expected.", actualWtFwpConditionValue0Size,
+			wtFwpConditionValue0_Size)
+	}
+}
+
+func TestWtFwpConditionValue0Offsets(t *testing.T) {
+
+	s := wtFwpConditionValue0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.value)) - sp
+
+	if offset != wtFwpConditionValue0_uint8_Offset {
+		t.Errorf("wtFwpConditionValue0.value offset is %d although %d is expected", offset, wtFwpConditionValue0_uint8_Offset)
+		return
+	}
+}
+
+func TestWtFwpV4AddrAndMaskSize(t *testing.T) {
+
+	const actualWtFwpV4AddrAndMaskSize = unsafe.Sizeof(wtFwpV4AddrAndMask{})
+
+	if actualWtFwpV4AddrAndMaskSize != wtFwpV4AddrAndMask_Size {
+		t.Errorf("Size of wtFwpV4AddrAndMask is %d, although %d is expected.", actualWtFwpV4AddrAndMaskSize,
+			wtFwpV4AddrAndMask_Size)
+	}
+}
+
+func TestWtFwpV4AddrAndMaskOffsets(t *testing.T) {
+
+	s := wtFwpV4AddrAndMask{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.mask)) - sp
+
+	if offset != wtFwpV4AddrAndMask_mask_Offset {
+		t.Errorf("wtFwpV4AddrAndMask.mask offset is %d although %d is expected", offset,
+			wtFwpV4AddrAndMask_mask_Offset)
+		return
+	}
+}
+
+func TestWtFwpV6AddrAndMaskSize(t *testing.T) {
+
+	const actualWtFwpV6AddrAndMaskSize = unsafe.Sizeof(wtFwpV6AddrAndMask{})
+
+	if actualWtFwpV6AddrAndMaskSize != wtFwpV6AddrAndMask_Size {
+		t.Errorf("Size of wtFwpV6AddrAndMask is %d, although %d is expected.", actualWtFwpV6AddrAndMaskSize,
+			wtFwpV6AddrAndMask_Size)
+	}
+}
+
+func TestWtFwpV6AddrAndMaskOffsets(t *testing.T) {
+
+	s := wtFwpV6AddrAndMask{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.prefixLength)) - sp
+
+	if offset != wtFwpV6AddrAndMask_prefixLength_Offset {
+		t.Errorf("wtFwpV6AddrAndMask.prefixLength offset is %d although %d is expected", offset,
+			wtFwpV6AddrAndMask_prefixLength_Offset)
+		return
+	}
+}
+
+func TestWtFwpValue0Size(t *testing.T) {
+
+	const actualWtFwpValue0Size = unsafe.Sizeof(wtFwpValue0{})
+
+	if actualWtFwpValue0Size != wtFwpValue0_Size {
+		t.Errorf("Size of wtFwpValue0 is %d, although %d is expected.", actualWtFwpValue0Size, wtFwpValue0_Size)
+	}
+}
+
+func TestWtFwpValue0Offsets(t *testing.T) {
+
+	s := wtFwpValue0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.value)) - sp
+
+	if offset != wtFwpValue0_value_Offset {
+		t.Errorf("wtFwpValue0.value offset is %d although %d is expected", offset, wtFwpValue0_value_Offset)
+		return
+	}
+}
+
+func TestWtFwpmDisplayData0Size(t *testing.T) {
+
+	const actualWtFwpmDisplayData0Size = unsafe.Sizeof(wtFwpmDisplayData0{})
+
+	if actualWtFwpmDisplayData0Size != wtFwpmDisplayData0_Size {
+		t.Errorf("Size of wtFwpmDisplayData0 is %d, although %d is expected.", actualWtFwpmDisplayData0Size,
+			wtFwpmDisplayData0_Size)
+	}
+}
+
+func TestWtFwpmDisplayData0Offsets(t *testing.T) {
+
+	s := wtFwpmDisplayData0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.description)) - sp
+
+	if offset != wtFwpmDisplayData0_description_Offset {
+		t.Errorf("wtFwpmDisplayData0.description offset is %d although %d is expected", offset,
+			wtFwpmDisplayData0_description_Offset)
+		return
+	}
+}
+
+func TestWtFwpmFilterCondition0Size(t *testing.T) {
+
+	const actualWtFwpmFilterCondition0Size = unsafe.Sizeof(wtFwpmFilterCondition0{})
+
+	if actualWtFwpmFilterCondition0Size != wtFwpmFilterCondition0_Size {
+		t.Errorf("Size of wtFwpmFilterCondition0 is %d, although %d is expected.",
+			actualWtFwpmFilterCondition0Size, wtFwpmFilterCondition0_Size)
+	}
+}
+
+func TestWtFwpmFilterCondition0Offsets(t *testing.T) {
+
+	s := wtFwpmFilterCondition0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.matchType)) - sp
+
+	if offset != wtFwpmFilterCondition0_matchType_Offset {
+		t.Errorf("wtFwpmFilterCondition0.matchType offset is %d although %d is expected", offset,
+			wtFwpmFilterCondition0_matchType_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.conditionValue)) - sp
+
+	if offset != wtFwpmFilterCondition0_conditionValue_Offset {
+		t.Errorf("wtFwpmFilterCondition0.conditionValue offset is %d although %d is expected", offset,
+			wtFwpmFilterCondition0_conditionValue_Offset)
+		return
+	}
+}
+
+func TestWtFwpmFilter0Size(t *testing.T) {
+
+	const actualWtFwpmFilter0Size = unsafe.Sizeof(wtFwpmFilter0{})
+
+	if actualWtFwpmFilter0Size != wtFwpmFilter0_Size {
+		t.Errorf("Size of wtFwpmFilter0 is %d, although %d is expected.", actualWtFwpmFilter0Size,
+			wtFwpmFilter0_Size)
+	}
+}
+
+func TestWtFwpmFilter0Offsets(t *testing.T) {
+
+	s := wtFwpmFilter0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.displayData)) - sp
+
+	if offset != wtFwpmFilter0_displayData_Offset {
+		t.Errorf("wtFwpmFilter0.displayData offset is %d although %d is expected", offset,
+			wtFwpmFilter0_displayData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.flags)) - sp
+
+	if offset != wtFwpmFilter0_flags_Offset {
+		t.Errorf("wtFwpmFilter0.flags offset is %d although %d is expected", offset, wtFwpmFilter0_flags_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerKey)) - sp
+
+	if offset != wtFwpmFilter0_providerKey_Offset {
+		t.Errorf("wtFwpmFilter0.providerKey offset is %d although %d is expected", offset,
+			wtFwpmFilter0_providerKey_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerData)) - sp
+
+	if offset != wtFwpmFilter0_providerData_Offset {
+		t.Errorf("wtFwpmFilter0.providerData offset is %d although %d is expected", offset,
+			wtFwpmFilter0_providerData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.layerKey)) - sp
+
+	if offset != wtFwpmFilter0_layerKey_Offset {
+		t.Errorf("wtFwpmFilter0.layerKey offset is %d although %d is expected", offset,
+			wtFwpmFilter0_layerKey_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.subLayerKey)) - sp
+
+	if offset != wtFwpmFilter0_subLayerKey_Offset {
+		t.Errorf("wtFwpmFilter0.subLayerKey offset is %d although %d is expected", offset,
+			wtFwpmFilter0_subLayerKey_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.weight)) - sp
+
+	if offset != wtFwpmFilter0_weight_Offset {
+		t.Errorf("wtFwpmFilter0.weight offset is %d although %d is expected", offset,
+			wtFwpmFilter0_weight_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.numFilterConditions)) - sp
+
+	if offset != wtFwpmFilter0_numFilterConditions_Offset {
+		t.Errorf("wtFwpmFilter0.numFilterConditions offset is %d although %d is expected", offset,
+			wtFwpmFilter0_numFilterConditions_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.filterCondition)) - sp
+
+	if offset != wtFwpmFilter0_filterCondition_Offset {
+		t.Errorf("wtFwpmFilter0.filterCondition offset is %d although %d is expected", offset,
+			wtFwpmFilter0_filterCondition_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.action)) - sp
+
+	if offset != wtFwpmFilter0_action_Offset {
+		t.Errorf("wtFwpmFilter0.action offset is %d although %d is expected", offset,
+			wtFwpmFilter0_action_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerContextKey)) - sp
+
+	if offset != wtFwpmFilter0_providerContextKey_Offset {
+		t.Errorf("wtFwpmFilter0.providerContextKey offset is %d although %d is expected", offset,
+			wtFwpmFilter0_providerContextKey_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.reserved)) - sp
+
+	if offset != wtFwpmFilter0_reserved_Offset {
+		t.Errorf("wtFwpmFilter0.reserved offset is %d although %d is expected", offset,
+			wtFwpmFilter0_reserved_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.filterId)) - sp
+
+	if offset != wtFwpmFilter0_filterId_Offset {
+		t.Errorf("wtFwpmFilter0.filterId offset is %d although %d is expected", offset,
+			wtFwpmFilter0_filterId_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.effectiveWeight)) - sp
+
+	if offset != wtFwpmFilter0_effectiveWeight_Offset {
+		t.Errorf("wtFwpmFilter0.effectiveWeight offset is %d although %d is expected", offset,
+			wtFwpmFilter0_effectiveWeight_Offset)
+		return
+	}
+}
+
+func TestWtFwpProvider0Size(t *testing.T) {
+
+	const actualWtFwpProvider0Size = unsafe.Sizeof(wtFwpProvider0{})
+
+	if actualWtFwpProvider0Size != wtFwpProvider0_Size {
+		t.Errorf("Size of wtFwpProvider0 is %d, although %d is expected.", actualWtFwpProvider0Size,
+			wtFwpProvider0_Size)
+	}
+}
+
+func TestWtFwpProvider0Offsets(t *testing.T) {
+
+	s := wtFwpProvider0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.displayData)) - sp
+
+	if offset != wtFwpProvider0_displayData_Offset {
+		t.Errorf("wtFwpProvider0.displayData offset is %d although %d is expected", offset,
+			wtFwpProvider0_displayData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.flags)) - sp
+
+	if offset != wtFwpProvider0_flags_Offset {
+		t.Errorf("wtFwpProvider0.flags offset is %d although %d is expected", offset,
+			wtFwpProvider0_flags_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerData)) - sp
+
+	if offset != wtFwpProvider0_providerData_Offset {
+		t.Errorf("wtFwpProvider0.providerData offset is %d although %d is expected", offset,
+			wtFwpProvider0_providerData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.serviceName)) - sp
+
+	if offset != wtFwpProvider0_serviceName_Offset {
+		t.Errorf("wtFwpProvider0.serviceName offset is %d although %d is expected", offset,
+			wtFwpProvider0_serviceName_Offset)
+		return
+	}
+}
+
+func TestWtFwpmSession0Size(t *testing.T) {
+
+	const actualWtFwpmSession0Size = unsafe.Sizeof(wtFwpmSession0{})
+
+	if actualWtFwpmSession0Size != wtFwpmSession0_Size {
+		t.Errorf("Size of wtFwpmSession0 is %d, although %d is expected.", actualWtFwpmSession0Size,
+			wtFwpmSession0_Size)
+	}
+}
+
+func TestWtFwpmSession0Offsets(t *testing.T) {
+
+	s := wtFwpmSession0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.displayData)) - sp
+
+	if offset != wtFwpmSession0_displayData_Offset {
+		t.Errorf("wtFwpmSession0.displayData offset is %d although %d is expected", offset,
+			wtFwpmSession0_displayData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.flags)) - sp
+
+	if offset != wtFwpmSession0_flags_Offset {
+		t.Errorf("wtFwpmSession0.flags offset is %d although %d is expected", offset, wtFwpmSession0_flags_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.txnWaitTimeoutInMSec)) - sp
+
+	if offset != wtFwpmSession0_txnWaitTimeoutInMSec_Offset {
+		t.Errorf("wtFwpmSession0.txnWaitTimeoutInMSec offset is %d although %d is expected", offset,
+			wtFwpmSession0_txnWaitTimeoutInMSec_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.processId)) - sp
+
+	if offset != wtFwpmSession0_processId_Offset {
+		t.Errorf("wtFwpmSession0.processId offset is %d although %d is expected", offset,
+			wtFwpmSession0_processId_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.sid)) - sp
+
+	if offset != wtFwpmSession0_sid_Offset {
+		t.Errorf("wtFwpmSession0.sid offset is %d although %d is expected", offset, wtFwpmSession0_sid_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.username)) - sp
+
+	if offset != wtFwpmSession0_username_Offset {
+		t.Errorf("wtFwpmSession0.username offset is %d although %d is expected", offset,
+			wtFwpmSession0_username_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.kernelMode)) - sp
+
+	if offset != wtFwpmSession0_kernelMode_Offset {
+		t.Errorf("wtFwpmSession0.kernelMode offset is %d although %d is expected", offset,
+			wtFwpmSession0_kernelMode_Offset)
+		return
+	}
+}
+
+func TestWtFwpmSublayer0Size(t *testing.T) {
+
+	const actualWtFwpmSublayer0Size = unsafe.Sizeof(wtFwpmSublayer0{})
+
+	if actualWtFwpmSublayer0Size != wtFwpmSublayer0_Size {
+		t.Errorf("Size of wtFwpmSublayer0 is %d, although %d is expected.", actualWtFwpmSublayer0Size,
+			wtFwpmSublayer0_Size)
+	}
+}
+
+func TestWtFwpmSublayer0Offsets(t *testing.T) {
+
+	s := wtFwpmSublayer0{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.displayData)) - sp
+
+	if offset != wtFwpmSublayer0_displayData_Offset {
+		t.Errorf("wtFwpmSublayer0.displayData offset is %d although %d is expected", offset,
+			wtFwpmSublayer0_displayData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.flags)) - sp
+
+	if offset != wtFwpmSublayer0_flags_Offset {
+		t.Errorf("wtFwpmSublayer0.flags offset is %d although %d is expected", offset,
+			wtFwpmSublayer0_flags_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerKey)) - sp
+
+	if offset != wtFwpmSublayer0_providerKey_Offset {
+		t.Errorf("wtFwpmSublayer0.providerKey offset is %d although %d is expected", offset,
+			wtFwpmSublayer0_providerKey_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.providerData)) - sp
+
+	if offset != wtFwpmSublayer0_providerData_Offset {
+		t.Errorf("wtFwpmSublayer0.providerData offset is %d although %d is expected", offset,
+			wtFwpmSublayer0_providerData_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.weight)) - sp
+
+	if offset != wtFwpmSublayer0_weight_Offset {
+		t.Errorf("wtFwpmSublayer0.weight offset is %d although %d is expected", offset,
+			wtFwpmSublayer0_weight_Offset)
+		return
+	}
+}
+
+func TestWtSecWinntAuthIdentityWSize(t *testing.T) {
+
+	const actualWtSecWinntAuthIdentityWSize = unsafe.Sizeof(wtSecWinntAuthIdentityW{})
+
+	if actualWtSecWinntAuthIdentityWSize != wtSecWinntAuthIdentityW_Size {
+		t.Errorf("Size of wtSecWinntAuthIdentityW is %d, although %d is expected.",
+			actualWtSecWinntAuthIdentityWSize, wtSecWinntAuthIdentityW_Size)
+	}
+}
+
+func TestWtSecWinntAuthIdentityWOffsets(t *testing.T) {
+
+	s := wtSecWinntAuthIdentityW{}
+	sp := uintptr(unsafe.Pointer(&s))
+
+	offset := uintptr(unsafe.Pointer(&s.UserLength)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_UserLength_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.UserLength offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_UserLength_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.Domain)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_Domain_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.Domain offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_Domain_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.DomainLength)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_DomainLength_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.DomainLength offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_DomainLength_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.Password)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_Password_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.Password offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_Password_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.PasswordLength)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_PasswordLength_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.PasswordLength offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_PasswordLength_Offset)
+		return
+	}
+
+	offset = uintptr(unsafe.Pointer(&s.Flags)) - sp
+
+	if offset != wtSecWinntAuthIdentityW_Flags_Offset {
+		t.Errorf("wtSecWinntAuthIdentityW.Flags offset is %d although %d is expected", offset,
+			wtSecWinntAuthIdentityW_Flags_Offset)
+		return
+	}
+}