- Wine-Devel - list.winehq.org

[PATCH v2 1/5] ws2_32: Move the getsockopt(IP_HDRINCL) implementation to ntdll.
by Zebediah Figura July 8, 2021

July 8, 2021

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/ntdll/unix/socket.c | 5 +++++ dlls/ws2_32/socket.c | 4 ++-- include/wine/afd.h | 1 + 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 46ed673b81e..1fbe1c8b663 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -1742,6 +1742,11 @@ NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc case IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP: return do_setsockopt( handle, io, IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP, in_buffer, in_size ); +#ifdef IP_HDRINCL + case IOCTL_AFD_WINE_GET_IP_HDRINCL: + return do_getsockopt( handle, io, IPPROTO_IP, IP_HDRINCL, out_buffer, out_size ); +#endif + default: { if ((code >> 16) == FILE_DEVICE_NETWORK) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 09f04fff60f..e38ca770ce5 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -2436,9 +2436,9 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, case WS_IP_DONTFRAGMENT: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_DONTFRAGMENT, optval, optlen ); -#ifdef IP_HDRINCL case WS_IP_HDRINCL: -#endif + return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_HDRINCL, optval, optlen ); + case WS_IP_MULTICAST_IF: case WS_IP_MULTICAST_LOOP: case WS_IP_MULTICAST_TTL: diff --git a/include/wine/afd.h b/include/wine/afd.h index 93c1744c031..3b293cc49f2 100644 --- a/include/wine/afd.h +++ b/include/wine/afd.h @@ -188,6 +188,7 @@ struct afd_get_events_params #define IOCTL_AFD_WINE_SET_IP_DONTFRAGMENT WINE_AFD_IOC(243) #define IOCTL_AFD_WINE_SET_IP_DROP_MEMBERSHIP WINE_AFD_IOC(244) #define IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP WINE_AFD_IOC(245) +#define IOCTL_AFD_WINE_GET_IP_HDRINCL WINE_AFD_IOC(246) struct afd_create_params { -- 2.30.2

2 5

[PATCH] include: Fix a byte offset in a comment.
by Zebediah Figura July 8, 2021

July 8, 2021

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- include/wine/winbase16.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/wine/winbase16.h b/include/wine/winbase16.h index 71493395f3a..1d052130e33 100644 --- a/include/wine/winbase16.h +++ b/include/wine/winbase16.h @@ -197,7 +197,7 @@ typedef struct _STACK16FRAME DWORD callfrom_ip; /* 18 callfrom tail IP */ DWORD module_cs; /* 1c module code segment */ DWORD relay; /* 20 relay function address */ - WORD entry_ip; /* 22 entry point IP */ + WORD entry_ip; /* 24 entry point IP */ DWORD entry_point; /* 26 API entry point to call, reused as mutex count */ WORD bp; /* 2a 16-bit stack frame chain */ WORD ip; /* 2c return address */ -- 2.30.2

1 0

[PATCH] crypt32: Implement CNG_RSA_PUBLIC_KEY_BLOB encoding/decoding
by Aaron Hill July 8, 2021

July 8, 2021

Add support for the OID CNG_RSA_PUBLIC_KEY_BLOB to CryptEncodeObjectEx and CryptDecodeObjectEx. This OID decodes to / encodes from memory consisting of a BCRYPT_RSAKEY_BLOB, followed in memory by the exponent and modulus in big-endian format. This allows the Visual Studio 2019 web installer to progress further - it now reachs the stubbed NCryptOpenStorageProvider function. To aid in debugging similar issues, CryptEncodeObjectEx and CryptDecodeObjectEX now print a FIXME when encountering an unknown OID/struct type, instead of silently returning an error. Signed-off-by: Aaron Hill <aa1ronham(a)gmail.com> --- v2: Correctly handle endianness --- dlls/crypt32/crypt32_private.h | 6 ++ dlls/crypt32/decode.c | 129 ++++++++++++++++++++++++--- dlls/crypt32/encode.c | 56 ++++++++++++ dlls/crypt32/tests/encode.c | 158 +++++++++++++++++++++++++++++++++ include/wincrypt.h | 1 + 5 files changed, 338 insertions(+), 12 deletions(-) diff --git a/dlls/crypt32/crypt32_private.h b/dlls/crypt32/crypt32_private.h index 9f8f43e7632..d165672b77a 100644 --- a/dlls/crypt32/crypt32_private.h +++ b/dlls/crypt32/crypt32_private.h @@ -42,6 +42,12 @@ BOOL CNG_ImportPubKey(CERT_PUBLIC_KEY_INFO *pubKeyInfo, BCRYPT_KEY_HANDLE *key) #define ASN_UNIVERSALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1c) #define ASN_BMPSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e) +/* Copies `len` bytes from `src` to `dst`. + * On a little-endian platform, additionally swaps + * the order of the bytes + */ +void CRYPT_memcpy_be(BYTE *dst, const BYTE *src, DWORD len); + BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN; typedef BOOL (WINAPI *CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *, diff --git a/dlls/crypt32/decode.c b/dlls/crypt32/decode.c index a0e78d62b4d..6dbd5b57f34 100644 --- a/dlls/crypt32/decode.c +++ b/dlls/crypt32/decode.c @@ -55,6 +55,27 @@ WINE_DEFAULT_DEBUG_CHANNEL(cryptasn); WINE_DECLARE_DEBUG_CHANNEL(crypt); +/* Copies `len` bytes from `src` to `dst`. + * On a little-endian platform, additionally swaps + * the order of the bytes + */ +#ifdef WORDS_BIGENDIAN + +void CRYPT_memcpy_be(BYTE *dst, const BYTE *src, size_t len) +{ + memcpy(dst, src, len); +} + +#else +void CRYPT_memcpy_be(BYTE *dst, const BYTE *src, size_t len) +{ + DWORD i; + for (i = 0; i < len; i++) { + dst[len - i - 1] = src[i]; + } +} +#endif + typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *, DWORD, DWORD, void *, DWORD *); typedef BOOL (WINAPI *CryptDecodeObjectExFunc)(DWORD, LPCSTR, const BYTE *, @@ -3870,7 +3891,31 @@ struct DECODED_RSA_PUB_KEY CRYPT_INTEGER_BLOB modulus; }; -static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType, +/* Helper function to decode an ASN.1 DER encoded RSA public key, writing the decoded + * key into 'decodedKey', and the length into 'size'. The memory + * for 'decodedKey' is allocated with 'CRYPT_DECODE_ALLOC_FLAG' + */ +static BOOL CRYPT_raw_decode_rsa_pub_key(struct DECODED_RSA_PUB_KEY **decodedKey, + DWORD *size, const BYTE *pbEncoded, DWORD cbEncoded) +{ + BOOL ret; + + struct AsnDecodeSequenceItem items[] = { + { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, modulus), + CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), + FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, modulus.pbData), + 0 }, + { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, pubexp), + CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 }, + }; + + ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items), + pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, decodedKey, + size, NULL, NULL); + return ret; +} + +static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey_Bcrypt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo) { @@ -3878,20 +3923,73 @@ static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType, __TRY { - struct AsnDecodeSequenceItem items[] = { - { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, modulus), - CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), - FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, modulus.pbData), - 0 }, - { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, pubexp), - CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 }, - }; struct DECODED_RSA_PUB_KEY *decodedKey = NULL; DWORD size = 0; - ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items), - pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &decodedKey, - &size, NULL, NULL); + TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, + pvStructInfo, *pcbStructInfo); + + ret = CRYPT_raw_decode_rsa_pub_key(&decodedKey, &size, pbEncoded, cbEncoded); + if (ret) + { + /* Header, exponent, and modulus */ + DWORD bytesNeeded = sizeof(BCRYPT_RSAKEY_BLOB) + sizeof(DWORD) + + decodedKey->modulus.cbData; + + if (!pvStructInfo) + { + *pcbStructInfo = bytesNeeded; + ret = TRUE; + } + else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, + pvStructInfo, pcbStructInfo, bytesNeeded))) + { + BCRYPT_RSAKEY_BLOB *hdr; + + if (dwFlags & CRYPT_DECODE_ALLOC_FLAG) + pvStructInfo = *(BYTE **)pvStructInfo; + + hdr = pvStructInfo; + hdr->Magic = BCRYPT_RSAPUBLIC_MAGIC; + hdr->BitLength = decodedKey->modulus.cbData * 8; + hdr->cbPublicExp = sizeof(DWORD); + hdr->cbModulus = decodedKey->modulus.cbData; + hdr->cbPrime1 = 0; + hdr->cbPrime2 = 0; + /* CNG_RSA_PUBLIC_KEY_BLOB always stores the exponent and modulus + * in big-endian format, so we need to convert from the native + * endianness + */ + CRYPT_memcpy_be((BYTE *)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB), + (BYTE *)&decodedKey->pubexp, sizeof(DWORD)); + CRYPT_memcpy_be((BYTE *)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB) + + sizeof(DWORD), decodedKey->modulus.pbData, + decodedKey->modulus.cbData); + } + LocalFree(decodedKey); + } + } + __EXCEPT_PAGE_FAULT + { + SetLastError(STATUS_ACCESS_VIOLATION); + ret = FALSE; + } + __ENDTRY + return ret; +} + + +static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType, + LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, + PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo) +{ + BOOL ret; + + __TRY + { + struct DECODED_RSA_PUB_KEY *decodedKey = NULL; + DWORD size = 0; + ret = CRYPT_raw_decode_rsa_pub_key(&decodedKey, &size, pbEncoded, cbEncoded); if (ret) { DWORD bytesNeeded = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) + @@ -4591,6 +4689,7 @@ static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded, } else { + /* FIXME This assumes that the system is little-endian */ CRYPT_INTEGER_BLOB *blob = pvStructInfo; *pcbStructInfo = bytesNeeded; @@ -6207,7 +6306,11 @@ static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType, break; case LOWORD(X509_ECC_SIGNATURE): decodeFunc = CRYPT_AsnDecodeEccSignature; + case LOWORD(CNG_RSA_PUBLIC_KEY_BLOB): + decodeFunc = CRYPT_AsnDecodeRsaPubKey_Bcrypt; break; + default: + FIXME("Unimplemented decoder for lpszStructType OID %d\n", LOWORD(lpszStructType)); } } else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS)) @@ -6264,6 +6367,8 @@ static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType, decodeFunc = CRYPT_AsnDecodeCTL; else if (!strcmp(lpszStructType, szOID_ECC_PUBLIC_KEY)) decodeFunc = CRYPT_AsnDecodeObjectIdentifier; + else + FIXME("Unsupported decoder for lpszStructType %s\n", lpszStructType); return decodeFunc; } diff --git a/dlls/crypt32/encode.c b/dlls/crypt32/encode.c index 02b235696ce..94c3033facc 100644 --- a/dlls/crypt32/encode.c +++ b/dlls/crypt32/encode.c @@ -3130,6 +3130,53 @@ static BOOL WINAPI CRYPT_AsnEncodeCertPolicyConstraints( return ret; } +static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey_Bcrypt(DWORD dwCertEncodingType, + LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, + PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) +{ + BOOL ret; + + __TRY + { + const BCRYPT_RSAKEY_BLOB *hdr = pvStructInfo; + + BYTE *pubexp = (BYTE*)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB); + BYTE *modulus = (BYTE*)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB) + hdr->cbPublicExp; + BYTE *pubexp_be = CryptMemAlloc(hdr->cbPublicExp); + BYTE *modulus_be = CryptMemAlloc(hdr->cbModulus); + CRYPT_INTEGER_BLOB pubexp_int = { hdr->cbPublicExp, pubexp_be }; + CRYPT_INTEGER_BLOB modulus_int = { hdr->cbModulus, modulus_be}; + + struct AsnEncodeSequenceItem items[] = { + { &modulus_int, CRYPT_AsnEncodeUnsignedInteger, 0 }, + { &pubexp_int, CRYPT_AsnEncodeInteger, 0 }, + }; + + /* CNG_RSA_PUBLIC_KEY_BLOB stores the exponent and modulus + * in big-endian format, so we need to convert them + * to the native endianness before encoding + */ + CRYPT_memcpy_be(pubexp_be, pubexp, hdr->cbPublicExp); + CRYPT_memcpy_be(modulus_be, modulus, hdr->cbModulus); + + ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, + ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); + + CryptMemFree(pubexp_be); + CryptMemFree(modulus_be); + } + __EXCEPT_PAGE_FAULT + { + ERR("PAGE FAULT\n"); + SetLastError(STATUS_ACCESS_VIOLATION); + ret = FALSE; + } + __ENDTRY + return ret; + +} + + static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) @@ -3350,6 +3397,7 @@ static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType, significantBytes = blob->cbData; if (significantBytes) { + /* FIXME This assumes that the system is little-endian */ if (blob->pbData[significantBytes - 1] & 0x80) { /* negative, lop off leading (little-endian) 0xffs */ @@ -3484,6 +3532,7 @@ static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType, } __EXCEPT_PAGE_FAULT { + ERR("Other page fault\n"); SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } @@ -4563,6 +4612,11 @@ static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType, case LOWORD(CMS_SIGNER_INFO): encodeFunc = CRYPT_AsnEncodeCMSSignerInfo; break; + case LOWORD(CNG_RSA_PUBLIC_KEY_BLOB): + encodeFunc = CRYPT_AsnEncodeRsaPubKey_Bcrypt; + break; + default: + FIXME("Unimplemented encoder for lpszStructType OID %d\n", LOWORD(lpszStructType)); } } else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS)) @@ -4617,6 +4671,8 @@ static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType, encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice; else if (!strcmp(lpszStructType, szOID_CTL)) encodeFunc = CRYPT_AsnEncodeCTL; + else + FIXME("Unsupported encoder for lpszStructType %s\n", lpszStructType); return encodeFunc; } diff --git a/dlls/crypt32/tests/encode.c b/dlls/crypt32/tests/encode.c index 9597f1dfec1..fbdb05992d5 100644 --- a/dlls/crypt32/tests/encode.c +++ b/dlls/crypt32/tests/encode.c @@ -31,6 +31,35 @@ static BOOL (WINAPI *pCryptDecodeObjectEx)(DWORD,LPCSTR,const BYTE*,DWORD,DWORD,PCRYPT_DECODE_PARA,void*,DWORD*); static BOOL (WINAPI *pCryptEncodeObjectEx)(DWORD,LPCSTR,const void*,DWORD,PCRYPT_ENCODE_PARA,void*,DWORD*); +/* Copies `len` bytes from `src` to `dst`. + * On a little-endian platform, additionally swaps + * the order of the bytes + */ +#ifdef WORDS_BIGENDIAN + +void CRYPT_memcpy_be(BYTE *dst, const BYTE *src, size_t len) +{ + memcpy(dst, src, len); +} + +#else +void CRYPT_memcpy_be(BYTE *dst, const BYTE *src, size_t len) +{ + DWORD i; + for (i = 0; i < len; i++) { + dst[len - i - 1] = src[i]; + } +} +#endif + +static void CRYPT_ReverseBytes(BYTE *dst, const BYTE *src, DWORD len) +{ + DWORD i; + for (i = 0; i < len; i++) { + dst[len - i - 1] = src[i]; + } +} + struct encodedInt { int val; @@ -2572,6 +2601,133 @@ static void test_decodeRsaPublicKey(DWORD dwEncoding) } } +static void test_encodeRsaPublicKey_Bcrypt(DWORD dwEncoding) +{ + BYTE toEncode[sizeof(BCRYPT_RSAKEY_BLOB) + sizeof(DWORD) + sizeof(modulus1)]; + BCRYPT_RSAKEY_BLOB *hdr = (BCRYPT_RSAKEY_BLOB *)toEncode; + BOOL ret; + BYTE *buf = NULL; + DWORD bufSize = 0, i; + DWORD pubexp = 65537; + + /* Verify that the Magic value doesn't matter */ + hdr->Magic = 1; + hdr->BitLength = sizeof(modulus1) * 8; + hdr->cbPublicExp = sizeof(DWORD); + hdr->cbModulus = sizeof(modulus1); + hdr->cbPrime1 = 0; + hdr->cbPrime2 = 0; + + /* CNG_RSA_PUBLIC_KEY_BLOB stores the exponent + * in big-endian format, so we need to it + * from native endianness before encoding + */ + CRYPT_memcpy_be(toEncode + sizeof(BCRYPT_RSAKEY_BLOB), (BYTE *)&pubexp, sizeof(DWORD)); + /* Our modulus is always stored in little-endian format, so we need to reverse + * the bytes to get it into big-endian format for CNG_RSA_PUBLIC_KEY_BLOB + */ + CRYPT_ReverseBytes(toEncode + sizeof(BCRYPT_RSAKEY_BLOB) + sizeof(DWORD), modulus1, sizeof(modulus1)); + + ret = pCryptEncodeObjectEx(dwEncoding, CNG_RSA_PUBLIC_KEY_BLOB, + toEncode, CRYPT_ENCODE_ALLOC_FLAG, NULL, &buf, &bufSize); + ok(ret, "CryptEncodeObjectEx failed: %08x\n", GetLastError()); + + /* Finally, all valid */ + hdr->Magic = BCRYPT_RSAPUBLIC_MAGIC; + for (i = 0; i < ARRAY_SIZE(rsaPubKeys); i++) + { + hdr->BitLength = rsaPubKeys[i].modulusLen * 8; + hdr->cbModulus = rsaPubKeys[i].modulusLen; + + /* Our modulus is always stored in little-endian format, so we need to reverse + * the bytes to get it into big-endian format for CNG_RSA_PUBLIC_KEY_BLOB + */ + CRYPT_ReverseBytes(toEncode + sizeof(BCRYPT_RSAKEY_BLOB) + sizeof(DWORD), + rsaPubKeys[i].modulus, rsaPubKeys[i].modulusLen); + + ret = pCryptEncodeObjectEx(dwEncoding, CNG_RSA_PUBLIC_KEY_BLOB, + toEncode, CRYPT_ENCODE_ALLOC_FLAG, NULL, &buf, &bufSize); + ok(ret, "CryptEncodeObjectEx failed: %08x\n", GetLastError()); + if (ret) + { + ok(bufSize == rsaPubKeys[i].encoded[1] + 2, + "Expected size %d, got %d\n", rsaPubKeys[i].encoded[1] + 2, + bufSize); + ok(!memcmp(buf, rsaPubKeys[i].encoded, bufSize), + "Unexpected value\n"); + LocalFree(buf); + } + } +} + +static void test_decodeRsaPublicKey_Bcrypt(DWORD dwEncoding) +{ + DWORD i; + LPBYTE buf = NULL; + LPBYTE leModulus = NULL; + DWORD bufSize = 0; + BOOL ret; + + /* Try with a bad length */ + ret = pCryptDecodeObjectEx(dwEncoding, CNG_RSA_PUBLIC_KEY_BLOB, + rsaPubKeys[0].encoded, rsaPubKeys[0].encoded[1], + CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &bufSize); + ok(!ret && (GetLastError() == CRYPT_E_ASN1_EOD || + GetLastError() == OSS_MORE_INPUT /* Win9x/NT4 */), + "Expected CRYPT_E_ASN1_EOD or OSS_MORE_INPUT, got %08x\n", + GetLastError()); + /* Now try success cases */ + for (i = 0; i < ARRAY_SIZE(rsaPubKeys); i++) + { + bufSize = 0; + ret = pCryptDecodeObjectEx(dwEncoding, CNG_RSA_PUBLIC_KEY_BLOB, + rsaPubKeys[i].encoded, rsaPubKeys[i].encoded[1] + 2, + CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &bufSize); + ok(ret, "CryptDecodeObjectEx failed: %08x\n", GetLastError()); + if (ret) + { + BCRYPT_RSAKEY_BLOB *hdr = (BCRYPT_RSAKEY_BLOB *)buf; + DWORD pubexp = 0; + /* CNG_RSA_PUBLIC_KEY_BLOB always stores the exponent and modulus + * in big-endian format, so we need to convert it to the native + * endianness + */ + CRYPT_memcpy_be((BYTE *)&pubexp, buf + sizeof(BCRYPT_RSAKEY_BLOB), hdr->cbPublicExp); + ok(bufSize >= sizeof(BCRYPT_RSAKEY_BLOB) + + rsaPubKeys[i].decodedModulusLen, + "Wrong size %d\n", bufSize); + ok(hdr->Magic == BCRYPT_RSAPUBLIC_MAGIC, + "Expected magic BCRYPT_RSAPUBLIC_MAGIC (%d), got %d\n", BCRYPT_RSAPUBLIC_MAGIC, + hdr->Magic); + ok(hdr->BitLength == rsaPubKeys[i].decodedModulusLen * 8, + "Wrong bit len %d\n", hdr->BitLength); + /* Windows decodes the exponent to 3 bytes, since it will fit. + * Our implementation currently unconditionally decodes to a DWORD (4 bytes) + */ + ok(hdr->cbPublicExp == sizeof(DWORD) || hdr->cbPublicExp == 3, "Expected cbPublicExp %d, got %d\n", + sizeof(DWORD), hdr->cbPublicExp); + ok(hdr->cbModulus == rsaPubKeys[i].decodedModulusLen, + "Wrong modulus len %d\n", hdr->cbModulus); + ok(hdr->cbPrime1 == 0,"Wrong cbPrime1 %d\n", hdr->cbPrime1); + ok(hdr->cbPrime2 == 0,"Wrong cbPrime2 %d\n", hdr->cbPrime2); + ok(pubexp== 65537, "Expected pubexp 65537, got %d\n", + pubexp); + + leModulus = HeapAlloc(GetProcessHeap(), 0, hdr->cbModulus); + /* Unconditionally reverse the bytes, since rsaPubKeys always stores + * the modulus in little-endian format, and CNG_RSA_PUBLIC_KEY_BLOB always + * stores the modulus in big-endian format */ + CRYPT_ReverseBytes(leModulus, buf + sizeof(BCRYPT_RSAKEY_BLOB) + hdr->cbPublicExp, + hdr->cbModulus); + ok(!memcmp(leModulus, + rsaPubKeys[i].modulus, rsaPubKeys[i].decodedModulusLen), + "Unexpected modulus\n"); + LocalFree(buf); + LocalFree(leModulus); + } + } +} + static const BYTE intSequence[] = { 0x30, 0x1b, 0x02, 0x01, 0x01, 0x02, 0x01, 0x7f, 0x02, 0x02, 0x00, 0x80, 0x02, 0x02, 0x01, 0x00, 0x02, 0x01, 0x80, 0x02, 0x02, 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d }; @@ -8547,6 +8703,8 @@ START_TEST(encode) test_decodeBasicConstraints(encodings[i]); test_encodeRsaPublicKey(encodings[i]); test_decodeRsaPublicKey(encodings[i]); + test_encodeRsaPublicKey_Bcrypt(encodings[i]); + test_decodeRsaPublicKey_Bcrypt(encodings[i]); test_encodeSequenceOfAny(encodings[i]); test_decodeSequenceOfAny(encodings[i]); test_encodeExtensions(encodings[i]); diff --git a/include/wincrypt.h b/include/wincrypt.h index 28bebf8dc4b..456f2f14446 100644 --- a/include/wincrypt.h +++ b/include/wincrypt.h @@ -3179,6 +3179,7 @@ typedef struct _CTL_FIND_SUBJECT_PARA #define CMC_ADD_EXTENSIONS ((LPCSTR)62) #define CMC_ADD_ATTRIBUTES ((LPCSTR)63) #define X509_CERTIFICATE_TEMPLATE ((LPCSTR)64) +#define CNG_RSA_PUBLIC_KEY_BLOB ((LPCSTR)72) #define X509_OBJECT_IDENTIFIER ((LPCSTR)73) #define PKCS7_SIGNER_INFO ((LPCSTR)500) #define CMS_SIGNER_INFO ((LPCSTR)501) -- 2.32.0

2 1

[PATCH 1/5] ws2_32: Move the getsockopt(IP_HDRINCL) implementation to ntdll.
by Zebediah Figura July 8, 2021

July 8, 2021

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/ntdll/unix/socket.c | 5 +++++ dlls/ws2_32/socket.c | 4 ++-- include/wine/afd.h | 1 + 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 46ed673b81e..1fbe1c8b663 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -1742,6 +1742,11 @@ NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc case IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP: return do_setsockopt( handle, io, IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP, in_buffer, in_size ); +#ifdef IP_HDRINCL + case IOCTL_AFD_WINE_GET_IP_HDRINCL: + return do_getsockopt( handle, io, IPPROTO_IP, IP_HDRINCL, out_buffer, out_size ); +#endif + default: { if ((code >> 16) == FILE_DEVICE_NETWORK) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 09f04fff60f..e38ca770ce5 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -2436,9 +2436,9 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, case WS_IP_DONTFRAGMENT: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_DONTFRAGMENT, optval, optlen ); -#ifdef IP_HDRINCL case WS_IP_HDRINCL: -#endif + return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_HDRINCL, optval, optlen ); + case WS_IP_MULTICAST_IF: case WS_IP_MULTICAST_LOOP: case WS_IP_MULTICAST_TTL: diff --git a/include/wine/afd.h b/include/wine/afd.h index 93c1744c031..3b293cc49f2 100644 --- a/include/wine/afd.h +++ b/include/wine/afd.h @@ -188,6 +188,7 @@ struct afd_get_events_params #define IOCTL_AFD_WINE_SET_IP_DONTFRAGMENT WINE_AFD_IOC(243) #define IOCTL_AFD_WINE_SET_IP_DROP_MEMBERSHIP WINE_AFD_IOC(244) #define IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP WINE_AFD_IOC(245) +#define IOCTL_AFD_WINE_GET_IP_HDRINCL WINE_AFD_IOC(246) struct afd_create_params { -- 2.30.2

2 8

[PATCH 1/6] ntoskrnl.exe/tests: Return success from IOCTL_HID_GET_STRING.
by Rémi Bernon July 7, 2021

July 7, 2021

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/ntoskrnl.exe/tests/driver_hid.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/ntoskrnl.exe/tests/driver_hid.c b/dlls/ntoskrnl.exe/tests/driver_hid.c index 1d5f7563e3f..aa9ff3e5e20 100644 --- a/dlls/ntoskrnl.exe/tests/driver_hid.c +++ b/dlls/ntoskrnl.exe/tests/driver_hid.c @@ -614,7 +614,9 @@ static NTSTATUS WINAPI driver_internal_ioctl(DEVICE_OBJECT *device, IRP *irp) ok(!in_size, "got input size %u\n", in_size); ok(out_size == 128, "got output size %u\n", out_size); - ret = STATUS_NOT_IMPLEMENTED; + memcpy(irp->UserBuffer, L"Wine Test", sizeof(L"Wine Test")); + irp->IoStatus.Information = sizeof(L"Wine Test"); + ret = STATUS_SUCCESS; break; default: -- 2.32.0

2 12

[PATCH v11 1/4] winevulkan: Support use of extensions which mustn't be exposed.
by Derek Lesho July 7, 2021

July 7, 2021

Signed-off-by: Derek Lesho <dlesho(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index e8534cbd5f5..c46ef02dcb9 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -124,6 +124,11 @@ UNSUPPORTED_EXTENSIONS = [ "VK_NV_external_memory_win32", ] +# Either internal extensions which aren't present on the win32 platform which +# winevulkan may nonetheless use, or extensions we want to generate headers for +# but not expose to applications (useful for test commits) +UNEXPOSED_EXTENSIONS = {} + # The Vulkan loader provides entry-points for core functionality and important # extensions. Based on vulkan-1.def this amounts to WSI extensions on 1.0.51. CORE_EXTENSIONS = [ @@ -513,8 +518,8 @@ class VkEnumValue(object): class VkFunction(object): - def __init__(self, _type=None, name=None, params=[], extensions=[], alias=None): - self.extensions = [] + def __init__(self, _type=None, name=None, params=[], alias=None): + self.extensions = set() self.name = name self.type = _type self.params = params @@ -657,6 +662,10 @@ class VkFunction(object): def needs_private_thunk(self): return self.thunk_type == ThunkType.PRIVATE + def needs_exposing(self): + # The function needs exposed if at-least one extension isn't both UNSUPPORTED and UNEXPOSED + return self.is_required() and (not self.extensions or not self.extensions.issubset(UNEXPOSED_EXTENSIONS)) + def pfn(self, prefix="p", call_conv=None, conv=False): """ Create function pointer. """ @@ -2682,7 +2691,7 @@ class VkGenerator(object): # Create thunks for instance and device functions. # Global functions don't go through the thunks. for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.is_global_func(): @@ -2702,6 +2711,8 @@ class VkGenerator(object): for ext in self.registry.extensions: if ext["type"] != "device": continue + if ext["name"] in UNEXPOSED_EXTENSIONS: + continue f.write(" \"{0}\",\n".format(ext["name"])) f.write("};\n\n") @@ -2711,6 +2722,8 @@ class VkGenerator(object): for ext in self.registry.extensions: if ext["type"] != "instance": continue + if ext["name"] in UNEXPOSED_EXTENSIONS: + continue f.write(" \"{0}\",\n".format(ext["name"])) f.write("};\n\n") @@ -2770,7 +2783,7 @@ class VkGenerator(object): f.write("const struct unix_funcs loader_funcs =\n") f.write("{\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type == ThunkType.NONE: continue @@ -2789,7 +2802,7 @@ class VkGenerator(object): # Generate prototypes for device and instance functions requiring a custom implementation. f.write("/* Functions for which we have custom implementations outside of the thunks. */\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.needs_thunk() and not vk_func.needs_private_thunk(): continue @@ -2888,7 +2901,7 @@ class VkGenerator(object): f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type != ThunkType.PUBLIC: continue @@ -2897,7 +2910,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_device_dispatch_table[] =\n{\n") for vk_func in self.registry.device_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2905,7 +2918,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_phys_dev_dispatch_table[] =\n{\n") for vk_func in self.registry.phys_dev_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2913,7 +2926,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_instance_dispatch_table[] =\n{\n") for vk_func in self.registry.instance_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2970,7 +2983,7 @@ class VkGenerator(object): f.write("struct unix_funcs\n") f.write("{\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type == ThunkType.NONE: continue @@ -3464,7 +3477,7 @@ class VkRegistry(object): # the XML file to handle this, but because of the manner in which we parse the XML # file we pre-populate from <commands> before we check if a command is enabled. if cmd_name in self.funcs: - self.funcs[cmd_name].extensions.append(ext_name) + self.funcs[cmd_name].extensions.add(ext_name) # Some extensions are not ready or have numbers reserved as a place holder. if ext.attrib["supported"] == "disabled": -- 2.32.0

2 4

Wineconf 2022 with XDC
by Jeremy White July 7, 2021

July 7, 2021

Hi all, As promised, here is a list of thoughts and concerns about Wineconf 2022, presuming it is held with XDC. First, XDC is attended by about 100-120 people, and usually has one main room, with scheduled tracks across three days, seemingly always a Wednesday-Friday. They also like to have a second room, which is mostly used as spillover, although there are sometimes scheduled work shops in that room that overlap with the main track. Wineconf has historically been on a Saturday/Sunday. The idea there was to try to make it easier for people that don't work professionally on Wine to attend. I don't know if that rationale still holds. I'm particularly curious to hear from people that don't work professionally on Wine as to whether or not this would discourage them from coming. I doubt that XDC would be interested in a different schedule, so that then leads me to two ideas: hold Wineconf interleaved with XDC on all or some combination of the Wednesday/Thursday/Friday, or hold Wineconf on the Friday/Saturday, so as to overlap by only one day. My sense is that the experiment would be most interesting with a full interleaving, but I'm really curious what others think. If we do the fully interleaved strategy, then I think we will want three rooms. We can schedule tracks in the two rooms, with one room being mostly X, and one room being mostly Wine, but with overlap allowed. The third room is social and spillover. That may be a bit of overkill. My sense is that both Wine and X.org have been running light on tracks of late, and so the added tracks from Wine may be enough to fill up the empty spaces left by X.org. But I think a little overkill is probably better than feeling like we're missing a room. If we do the overlap option, then I'd probably just get two rooms, as I think x.org could give over their normal 'second' room to us for one day. My thinking is to pin down some of these details, and then ask the Wine committee to approve Wineconf 2022 with those parameters so that we can submit an RFP to X.org. Note that the deadline for RFPs to x.org is September 1, 2021, which is why I am bringing this up now. I'd appreciate other thoughts and things I might have missed. Cheers, Jeremy

1 0

[PATCH 1/3] tests: Add shader tests for dynamically indexed unbounded resource arrays.
by Conor McCarthy July 7, 2021

July 7, 2021

From: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- tests/d3d12.c | 199 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 198 insertions(+), 1 deletion(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index ce6d6b36..4397c063 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -740,7 +740,7 @@ static ID3D12PipelineState *create_compute_pipeline_state_(unsigned int line, ID ID3D12RootSignature *root_signature, const D3D12_SHADER_BYTECODE cs) { D3D12_COMPUTE_PIPELINE_STATE_DESC pipeline_state_desc; - ID3D12PipelineState *pipeline_state; + ID3D12PipelineState *pipeline_state = NULL; HRESULT hr; memset(&pipeline_state_desc, 0, sizeof(pipeline_state_desc)); @@ -33837,6 +33837,202 @@ static void test_hull_shader_patch_constant_inputs(void) destroy_test_context(&context); } +static void test_resource_arrays(void) +{ + ID3D12Resource *input_buffers[8], *output_buffers[6]; + D3D12_ROOT_SIGNATURE_DESC root_signature_desc; + D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc; + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc; + ID3D12GraphicsCommandList *command_list; + unsigned int descriptor_count; + struct resource_readback rb; + struct test_context context; + ID3D12DescriptorHeap *heap; + ID3D12CommandQueue *queue; + ID3D12Device *device; + unsigned int i; + HRESULT hr; + + static const D3D12_DESCRIPTOR_RANGE descriptor_ranges[] = + { + {D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 8, 2, 2, 0}, + {D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 6, 1, 3, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND}, + }; + + static const struct uvec4 cb_data[] = + { + {0, 0}, + {1, 1}, + {0, 5}, + {1, 4}, + {2, 0}, + {3, 1}, + }; + + static const D3D12_ROOT_PARAMETER root_parameters[] = + { + {D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, + .DescriptorTable = {ARRAY_SIZE(descriptor_ranges), descriptor_ranges}}, + {D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS, .Constants = {2, 1, ARRAY_SIZE(cb_data) * 4}}, + }; + + static const DWORD cs_code[] = + { +#if 0 + cbuffer cb : register(b2, space1) + { + uint2 c[6]; + } + + Buffer<uint> t1[2] : register(t2, space2); + Buffer<uint> t2[] : register(t4, space2); + + RWBuffer<uint> u1[2] : register(u1, space3); + RWBuffer<uint> u2[] : register(u3, space3); + + [numthreads(1, 1, 1)] + void main() + { + u1[c[0].x][0] = t1[c[0].y][0]; + u1[c[1].x][0] = t1[c[1].y][0]; + u2[c[2].x][0] = t2[c[2].y][0]; + u2[c[3].x][0] = t2[c[3].y][0]; + u2[c[4].x][0] = t2[c[4].y][0]; + u2[c[5].x][0] = t2[c[5].y][0]; + } +#endif + 0x43425844, 0xef615fd3, 0x708c1d93, 0xdb9908b4, 0xb1853d57, 0x00000001, 0x000004c8, 0x00000003, + 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x00000474, 0x00050051, 0x0000011d, 0x0100086a, + 0x07000059, 0x00308e46, 0x00000000, 0x00000002, 0x00000002, 0x00000006, 0x00000001, 0x07000858, + 0x00307e46, 0x00000000, 0x00000002, 0x00000003, 0x00004444, 0x00000002, 0x07000858, 0x00307e46, + 0x00000001, 0x00000004, 0xffffffff, 0x00004444, 0x00000002, 0x0700089c, 0x0031ee46, 0x00000000, + 0x00000001, 0x00000002, 0x00004444, 0x00000003, 0x0700089c, 0x0031ee46, 0x00000001, 0x00000003, + 0xffffffff, 0x00004444, 0x00000003, 0x02000068, 0x00000001, 0x0400009b, 0x00000001, 0x00000001, + 0x00000001, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000000, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000000, 0x00000002, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000000, 0x0d0000a4, 0x0621e0f2, 0x00000000, 0x00000001, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000001, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000000, 0x00000002, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000001, 0x0d0000a4, 0x0621e0f2, 0x00000000, 0x00000001, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000002, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000001, 0x00000004, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000002, 0x0d0000a4, 0x0621e0f2, 0x00000001, 0x00000003, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000003, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000001, 0x00000004, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000003, 0x0d0000a4, 0x0621e0f2, 0x00000001, 0x00000003, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000004, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000001, 0x00000004, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000004, 0x0d0000a4, 0x0621e0f2, 0x00000001, 0x00000003, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x07000036, 0x00100012, 0x00000000, 0x0030801a, 0x00000000, 0x00000002, 0x00000005, + 0x0d00002d, 0x00100012, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x06207e46, 0x00000001, 0x00000004, 0x0010000a, 0x00000000, 0x07000036, 0x00100022, 0x00000000, + 0x0030800a, 0x00000000, 0x00000002, 0x00000005, 0x0d0000a4, 0x0621e0f2, 0x00000001, 0x00000003, + 0x0010001a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100006, + 0x00000000, 0x0100003e, + }; + + static const uint32_t srv_data[] = {0x1, 0x4, 0x9, 0x10, 0x19, 0x24, 0x31, 0x40}; + static const uint32_t uav_data[] = {0x1, 0x4, 0x40, 0x31, 0x9, 0x10}; + + if (!init_compute_test_context(&context)) + return; + device = context.device; + command_list = context.list; + queue = context.queue; + + memset(&root_signature_desc, 0, sizeof(root_signature_desc)); + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters); + root_signature_desc.pParameters = root_parameters; + hr = create_root_signature(device, &root_signature_desc, &context.root_signature); + ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); + + for (i = 0, descriptor_count = 0; i < ARRAY_SIZE(descriptor_ranges); ++i) + { + descriptor_count += descriptor_ranges[i].NumDescriptors; + } + heap = create_gpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, descriptor_count); + + for (i = 0; i < ARRAY_SIZE(input_buffers); ++i) + { + input_buffers[i] = create_default_buffer(device, sizeof(uint32_t), + D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_COPY_DEST); + upload_buffer_data(input_buffers[i], 0, sizeof(srv_data[i]), &srv_data[i], queue, command_list); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, input_buffers[i], + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + memset(&srv_desc, 0, sizeof(srv_desc)); + srv_desc.Format = DXGI_FORMAT_R32_UINT; + srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; + srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + srv_desc.Buffer.FirstElement = 0; + srv_desc.Buffer.NumElements = 1; + ID3D12Device_CreateShaderResourceView(device, input_buffers[i], &srv_desc, + get_cpu_descriptor_handle(&context, heap, i)); + } + + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) + { + output_buffers[i] = create_default_buffer(device, sizeof(uint32_t), + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + + memset(&uav_desc, 0, sizeof(uav_desc)); + uav_desc.Format = DXGI_FORMAT_R32_UINT; + uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; + uav_desc.Buffer.FirstElement = 0; + uav_desc.Buffer.NumElements = 1; + ID3D12Device_CreateUnorderedAccessView(device, output_buffers[i], NULL, &uav_desc, + get_cpu_descriptor_handle(&context, heap, ARRAY_SIZE(input_buffers) + i)); + } + + context.pipeline_state = create_compute_pipeline_state(device, context.root_signature, + shader_bytecode(cs_code, sizeof(cs_code))); + if (!context.pipeline_state) + { + skip("Shader descriptor arrays are not supported.\n"); + goto done; + } + + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_SetComputeRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(command_list, + 0, get_gpu_descriptor_handle(&context, heap, 0)); + ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(command_list, 1, ARRAY_SIZE(cb_data) * 4, cb_data, 0); + + ID3D12GraphicsCommandList_Dispatch(command_list, 1, 1, 1); + + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) + { + vkd3d_test_set_context("buffer %u", i); + transition_sub_resource_state(command_list, output_buffers[i], 0, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_buffer_readback_with_command_list(output_buffers[i], DXGI_FORMAT_R32_UINT, &rb, queue, command_list); + todo_if(i) + check_readback_data_uint(&rb, NULL, uav_data[i], 0); + release_resource_readback(&rb); + reset_command_list(command_list, context.allocator); + } + +done: + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) + ID3D12Resource_Release(output_buffers[i]); + for (i = 0; i < ARRAY_SIZE(input_buffers); ++i) + ID3D12Resource_Release(input_buffers[i]); + ID3D12DescriptorHeap_Release(heap); + destroy_test_context(&context); +} + START_TEST(d3d12) { parse_args(argc, argv); @@ -34005,4 +34201,5 @@ START_TEST(d3d12) run_test(test_sampler_register_space); run_test(test_hull_shader_relative_addressing); run_test(test_hull_shader_patch_constant_inputs); + run_test(test_resource_arrays); } -- 2.31.1

3 4

[PATCH] oleaut32: Fix a trace containing a null character.
by Francois Gouget July 7, 2021

July 7, 2021

printf("%c Hello\n", 0) works but not TRACE("%c Hello\n", 0) because the string is formatted before printing. Work around the issue with wine_dbgstr_w(). Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- As an alternative, maybe this issue could be avoided by passing the string size to __wine_dbg_output(). --- dlls/oleaut32/variant.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c index ace33a006f4..129e13da17d 100644 --- a/dlls/oleaut32/variant.c +++ b/dlls/oleaut32/variant.c @@ -1554,8 +1554,8 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID break; default: WARN("buffer too small for LOCALE_SCURRENCY\n"); } - TRACE("lcid 0x%x, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal, - lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2); + TRACE("lcid 0x%x, cCurrencyLocal=%d,%d %s\n", lcid, lpChars->cCurrencyLocal, + lpChars->cCurrencyLocal2, wine_dbgstr_w(buff)); memcpy(&lastChars, lpChars, sizeof(defaultChars)); lastLcid = lcid; -- 2.20.1

1 0

[PATCH] mfplat: Use D3DFORMAT for dxgi buffer copy function
by Adrian Thiele July 7, 2021

July 7, 2021

Signed-off-by: Adrian Thiele <adrian.thiele(a)live.de> --- dlls/mfplat/buffer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mfplat/buffer.c b/dlls/mfplat/buffer.c index c1829043e1b..9081dc39eab 100644 --- a/dlls/mfplat/buffer.c +++ b/dlls/mfplat/buffer.c @@ -1473,7 +1473,7 @@ static HRESULT create_dxgi_surface_buffer(IUnknown *surface, unsigned int sub_re object->_2d.width = stride; object->_2d.height = desc.Height; object->max_length = object->_2d.plane_size; - object->_2d.copy_image = get_2d_buffer_copy_func(desc.Format); + object->_2d.copy_image = get_2d_buffer_copy_func(format); if (FAILED(hr = init_attributes_object(&object->dxgi_surface.attributes, 0))) { -- 2.32.0

3 2