mirror of https://github.com/FreeRDP/FreeRDP
Merge pull request #10601 from akallabeth/warn-fix
[warnings] fix a bunch of them
This commit is contained in:
commit
7295f8a3b8
|
@ -28,6 +28,7 @@ Checks: >
|
|||
-cert-dcl16-c,
|
||||
-cert-env33-c,
|
||||
-cert-dcl50-cpp,
|
||||
-clang-analyzer-optin.performance.Padding,
|
||||
-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
|
||||
-clang-analyzer-valist.Uninitialized,
|
||||
-cppcoreguidelines-pro-bounds-array-to-pointer-decay,
|
||||
|
|
|
@ -52,8 +52,8 @@ typedef struct
|
|||
krb5_context krbContext;
|
||||
} RDPEAR_PLUGIN;
|
||||
|
||||
const BYTE payloadHeader[16] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
static const BYTE payloadHeader[16] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
|
||||
static krb5_error_code RPC_ENCRYPTION_KEY_to_keyblock(krb5_context ctx,
|
||||
const KERB_RPC_ENCRYPTION_KEY* key,
|
||||
|
@ -125,12 +125,12 @@ static krb5_error_code kerb_do_encrypt(krb5_context ctx, const KERB_RPC_ENCRYPTI
|
|||
rv = krb5_c_encrypt_length(ctx, keyblock->enctype, data.length, &elen);
|
||||
if (rv)
|
||||
goto out;
|
||||
if (!elen)
|
||||
if (!elen || (elen > UINT32_MAX))
|
||||
{
|
||||
rv = KRB5_PARSE_MALFORMED;
|
||||
goto out;
|
||||
}
|
||||
enc.ciphertext.length = elen;
|
||||
enc.ciphertext.length = (unsigned int)elen;
|
||||
enc.ciphertext.data = malloc(elen);
|
||||
if (!enc.ciphertext.data)
|
||||
{
|
||||
|
@ -198,8 +198,11 @@ static BOOL rdpear_send_payload(RDPEAR_PLUGIN* rdpear, IWTSVirtualChannelCallbac
|
|||
if (!unencodedContent)
|
||||
goto out;
|
||||
|
||||
size_t unencodedLen = Stream_GetPosition(unencodedContent);
|
||||
SecBuffer inBuffer = { unencodedLen, SECBUFFER_DATA, Stream_Buffer(unencodedContent) };
|
||||
const size_t unencodedLen = Stream_GetPosition(unencodedContent);
|
||||
if (unencodedLen > ULONG_MAX)
|
||||
goto out;
|
||||
|
||||
SecBuffer inBuffer = { (ULONG)unencodedLen, SECBUFFER_DATA, Stream_Buffer(unencodedContent) };
|
||||
|
||||
if (!freerdp_nla_encrypt(rdpear->rdp_context, &inBuffer, &cryptedBuffer))
|
||||
goto out;
|
||||
|
@ -219,8 +222,12 @@ static BOOL rdpear_send_payload(RDPEAR_PLUGIN* rdpear, IWTSVirtualChannelCallbac
|
|||
|
||||
Stream_Write(finalStream, cryptedBuffer.pvBuffer, cryptedBuffer.cbBuffer);
|
||||
|
||||
UINT status = callback->channel->Write(callback->channel, Stream_GetPosition(finalStream),
|
||||
Stream_Buffer(finalStream), NULL);
|
||||
const size_t pos = Stream_GetPosition(finalStream);
|
||||
if (pos > ULONG_MAX)
|
||||
goto out;
|
||||
|
||||
UINT status =
|
||||
callback->channel->Write(callback->channel, (ULONG)pos, Stream_Buffer(finalStream), NULL);
|
||||
ret = (status == CHANNEL_RC_OK);
|
||||
if (!ret)
|
||||
WLog_DBG(TAG, "rdpear_send_payload=0x%x", status);
|
||||
|
@ -260,11 +267,12 @@ static BOOL rdpear_prepare_response(NdrContext* rcontext, UINT16 callId, UINT32
|
|||
*pwcontext = wcontext;
|
||||
ret = TRUE;
|
||||
out:
|
||||
if (!ret)
|
||||
ndr_context_destroy(&wcontext);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_version(RDPEAR_PLUGIN* rdpear, IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus, UINT32* pversion)
|
||||
static BOOL rdpear_kerb_version(NdrContext* rcontext, wStream* s, UINT32* pstatus, UINT32* pversion)
|
||||
{
|
||||
*pstatus = ERROR_INVALID_DATA;
|
||||
|
||||
|
@ -277,10 +285,8 @@ static BOOL rdpear_kerb_version(RDPEAR_PLUGIN* rdpear, IWTSVirtualChannelCallbac
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_ComputeTgsChecksum(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
KERB_ASN1_DATA* resp)
|
||||
static BOOL rdpear_kerb_ComputeTgsChecksum(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext, wStream* s,
|
||||
UINT32* pstatus, KERB_ASN1_DATA* resp)
|
||||
{
|
||||
ComputeTgsChecksumReq req = { 0 };
|
||||
krb5_checksum checksum = { 0 };
|
||||
|
@ -306,7 +312,10 @@ static BOOL rdpear_kerb_ComputeTgsChecksum(RDPEAR_PLUGIN* rdpear,
|
|||
|
||||
resp->Pdu = 8;
|
||||
resp->Asn1Buffer = Stream_Buffer(asn1Payload);
|
||||
resp->Asn1BufferHints.count = Stream_GetPosition(asn1Payload);
|
||||
const size_t pos = Stream_GetPosition(asn1Payload);
|
||||
if (pos > UINT32_MAX)
|
||||
goto out;
|
||||
resp->Asn1BufferHints.count = (UINT32)pos;
|
||||
*pstatus = 0;
|
||||
|
||||
out:
|
||||
|
@ -316,10 +325,8 @@ out:
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_BuildEncryptedAuthData(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
KERB_ASN1_DATA* asn1)
|
||||
static BOOL rdpear_kerb_BuildEncryptedAuthData(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext,
|
||||
wStream* s, UINT32* pstatus, KERB_ASN1_DATA* asn1)
|
||||
{
|
||||
BuildEncryptedAuthDataReq req = { 0 };
|
||||
krb5_data encrypted = { 0 };
|
||||
|
@ -347,7 +354,10 @@ static BOOL rdpear_kerb_BuildEncryptedAuthData(RDPEAR_PLUGIN* rdpear,
|
|||
// winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(asn1Payload), Stream_GetPosition(asn1Payload));
|
||||
asn1->Pdu = 6;
|
||||
asn1->Asn1Buffer = Stream_Buffer(asn1Payload);
|
||||
asn1->Asn1BufferHints.count = Stream_GetPosition(asn1Payload);
|
||||
const size_t pos = Stream_GetPosition(asn1Payload);
|
||||
if (pos > UINT32_MAX)
|
||||
goto out;
|
||||
asn1->Asn1BufferHints.count = (UINT32)pos;
|
||||
*pstatus = 0;
|
||||
|
||||
out:
|
||||
|
@ -365,11 +375,13 @@ static char* KERB_RPC_UNICODESTR_to_charptr(const RPC_UNICODE_STRING* src)
|
|||
|
||||
static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData, BOOL* haveData)
|
||||
{
|
||||
WinPrAsn1Decoder dec, dec2, dec3;
|
||||
WinPrAsn1Decoder dec = { 0 };
|
||||
WinPrAsn1Decoder dec2 = { 0 };
|
||||
WinPrAsn1Decoder dec3 = { 0 };
|
||||
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
|
||||
BOOL error = FALSE;
|
||||
WinPrAsn1_INTEGER adType;
|
||||
WinPrAsn1_OctetString os;
|
||||
WinPrAsn1_INTEGER adType = 0;
|
||||
WinPrAsn1_OctetString os = { 0 };
|
||||
|
||||
*haveData = FALSE;
|
||||
if (!WinPrAsn1DecReadSequence(&dec, &dec2))
|
||||
|
@ -386,8 +398,11 @@ static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData,
|
|||
!WinPrAsn1DecReadContextualOctetString(&dec3, 1, &error, &os, FALSE))
|
||||
return FALSE;
|
||||
|
||||
if (os.len > UINT32_MAX)
|
||||
return FALSE;
|
||||
|
||||
authData->ad_type = adType;
|
||||
authData->length = os.len;
|
||||
authData->length = (unsigned int)os.len;
|
||||
authData->contents = os.data;
|
||||
*haveData = TRUE;
|
||||
return TRUE;
|
||||
|
@ -395,7 +410,8 @@ static BOOL extractAuthData(const KERB_ASN1_DATA* src, krb5_authdata* authData,
|
|||
|
||||
static BOOL extractChecksum(const KERB_ASN1_DATA* src, krb5_checksum* dst)
|
||||
{
|
||||
WinPrAsn1Decoder dec, dec2;
|
||||
WinPrAsn1Decoder dec = { 0 };
|
||||
WinPrAsn1Decoder dec2 = { 0 };
|
||||
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
|
||||
BOOL error = FALSE;
|
||||
WinPrAsn1_OctetString os;
|
||||
|
@ -403,13 +419,15 @@ static BOOL extractChecksum(const KERB_ASN1_DATA* src, krb5_checksum* dst)
|
|||
if (!WinPrAsn1DecReadSequence(&dec, &dec2))
|
||||
return FALSE;
|
||||
|
||||
WinPrAsn1_INTEGER cksumtype;
|
||||
WinPrAsn1_INTEGER cksumtype = 0;
|
||||
if (!WinPrAsn1DecReadContextualInteger(&dec2, 0, &error, &cksumtype) ||
|
||||
!WinPrAsn1DecReadContextualOctetString(&dec2, 1, &error, &os, FALSE))
|
||||
return FALSE;
|
||||
|
||||
if (os.len > UINT32_MAX)
|
||||
return FALSE;
|
||||
dst->checksum_type = cksumtype;
|
||||
dst->length = os.len;
|
||||
dst->length = (unsigned int)os.len;
|
||||
dst->contents = os.data;
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -429,9 +447,8 @@ static void krb5_free_principal_contents(krb5_context ctx, krb5_principal princi
|
|||
krb5_free_data(ctx, principal->data);
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext,
|
||||
wStream* s, UINT32* pstatus,
|
||||
CreateApReqAuthenticatorResp* resp)
|
||||
{
|
||||
krb5_error_code rv = 0;
|
||||
|
@ -449,9 +466,9 @@ static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
|
|||
!ndr_treat_deferred_read(rcontext, s))
|
||||
goto out;
|
||||
|
||||
krb5_authdata authdata;
|
||||
krb5_authdata authdata = { 0 };
|
||||
krb5_authdata* authDataPtr[2] = { &authdata, NULL };
|
||||
BOOL haveData;
|
||||
BOOL haveData = 0;
|
||||
|
||||
if (!extractAuthData(req.AuthData, &authdata, &haveData))
|
||||
{
|
||||
|
@ -482,8 +499,11 @@ static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
|
|||
.authorization_data = haveData ? authDataPtr : NULL };
|
||||
|
||||
client.type = req.ClientName->NameType;
|
||||
if (req.ClientName->nameHints.count > INT32_MAX)
|
||||
goto out;
|
||||
|
||||
client.length = (krb5_int32)req.ClientName->nameHints.count;
|
||||
client.data = calloc(client.length, sizeof(krb5_data));
|
||||
client.data = calloc(req.ClientName->nameHints.count, sizeof(krb5_data));
|
||||
if (!client.data)
|
||||
goto out;
|
||||
|
||||
|
@ -492,12 +512,12 @@ static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
|
|||
client.data[i].data = KERB_RPC_UNICODESTR_to_charptr(&req.ClientName->Names[i]);
|
||||
if (!client.data[i].data)
|
||||
goto out;
|
||||
client.data[i].length = strlen(client.data[i].data);
|
||||
client.data[i].length = (unsigned int)strnlen(client.data[i].data, UINT32_MAX);
|
||||
}
|
||||
client.realm.data = KERB_RPC_UNICODESTR_to_charptr(req.ClientRealm);
|
||||
if (!client.realm.data)
|
||||
goto out;
|
||||
client.realm.length = strlen(client.realm.data);
|
||||
client.realm.length = (unsigned int)strnlen(client.realm.data, UINT32_MAX);
|
||||
authent.client = &client;
|
||||
|
||||
krb5_checksum checksum;
|
||||
|
@ -546,7 +566,10 @@ static BOOL rdpear_kerb_CreateApReqAuthenticator(RDPEAR_PLUGIN* rdpear,
|
|||
// winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(asn1EncodedAuth),
|
||||
// Stream_GetPosition(asn1EncodedAuth));
|
||||
|
||||
resp->Authenticator.Asn1BufferHints.count = Stream_GetPosition(asn1EncodedAuth);
|
||||
const size_t size = Stream_GetPosition(asn1EncodedAuth);
|
||||
if (size > UINT32_MAX)
|
||||
goto out;
|
||||
resp->Authenticator.Asn1BufferHints.count = (UINT32)size;
|
||||
resp->Authenticator.Asn1Buffer = Stream_Buffer(asn1EncodedAuth);
|
||||
resp->AuthenticatorTime.QuadPart = krb5_time_to_FILETIME(&authent.ctime, authent.cusec);
|
||||
*pstatus = 0;
|
||||
|
@ -566,27 +589,28 @@ out:
|
|||
|
||||
static BOOL rdpear_findEncryptedData(const KERB_ASN1_DATA* src, int* penctype, krb5_data* data)
|
||||
{
|
||||
WinPrAsn1Decoder dec, dec2;
|
||||
WinPrAsn1Decoder dec = { 0 };
|
||||
WinPrAsn1Decoder dec2 = { 0 };
|
||||
WinPrAsn1Decoder_InitMem(&dec, WINPR_ASN1_DER, src->Asn1Buffer, src->Asn1BufferHints.count);
|
||||
BOOL error = FALSE;
|
||||
WinPrAsn1_INTEGER encType;
|
||||
WinPrAsn1_OctetString os;
|
||||
WinPrAsn1_INTEGER encType = 0;
|
||||
WinPrAsn1_OctetString os = { 0 };
|
||||
|
||||
if (!WinPrAsn1DecReadSequence(&dec, &dec2) ||
|
||||
!WinPrAsn1DecReadContextualInteger(&dec2, 0, &error, &encType) ||
|
||||
!WinPrAsn1DecReadContextualOctetString(&dec2, 2, &error, &os, FALSE))
|
||||
return FALSE;
|
||||
|
||||
if (os.len > UINT32_MAX)
|
||||
return FALSE;
|
||||
data->data = (char*)os.data;
|
||||
data->length = os.len;
|
||||
data->length = (unsigned int)os.len;
|
||||
*penctype = encType;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_UnpackKdcReplyBody(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
UnpackKdcReplyBodyResp* resp)
|
||||
static BOOL rdpear_kerb_UnpackKdcReplyBody(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext, wStream* s,
|
||||
UINT32* pstatus, UnpackKdcReplyBodyResp* resp)
|
||||
{
|
||||
UnpackKdcReplyBodyReq req = { 0 };
|
||||
|
||||
|
@ -607,8 +631,8 @@ static BOOL rdpear_kerb_UnpackKdcReplyBody(RDPEAR_PLUGIN* rdpear,
|
|||
// winpr_HexDump(TAG, WLOG_DEBUG, req.EncryptedData->Asn1Buffer,
|
||||
// req.EncryptedData->Asn1BufferHints.count);
|
||||
|
||||
krb5_data asn1Data;
|
||||
int encType;
|
||||
krb5_data asn1Data = { 0 };
|
||||
int encType = 0;
|
||||
if (!rdpear_findEncryptedData(req.EncryptedData, &encType, &asn1Data) || !asn1Data.length)
|
||||
goto out;
|
||||
|
||||
|
@ -623,10 +647,8 @@ out:
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_DecryptApReply(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
KERB_ASN1_DATA* resp)
|
||||
static BOOL rdpear_kerb_DecryptApReply(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext, wStream* s,
|
||||
UINT32* pstatus, KERB_ASN1_DATA* resp)
|
||||
{
|
||||
DecryptApReplyReq req = { 0 };
|
||||
|
||||
|
@ -639,8 +661,8 @@ static BOOL rdpear_kerb_DecryptApReply(RDPEAR_PLUGIN* rdpear,
|
|||
// winpr_HexDump(TAG, WLOG_DEBUG, req.EncryptedReply->Asn1Buffer,
|
||||
// req.EncryptedReply->Asn1BufferHints.count);
|
||||
|
||||
krb5_data asn1Data;
|
||||
int encType;
|
||||
krb5_data asn1Data = { 0 };
|
||||
int encType = 0;
|
||||
if (!rdpear_findEncryptedData(req.EncryptedReply, &encType, &asn1Data) || !asn1Data.length)
|
||||
goto out;
|
||||
|
||||
|
@ -661,10 +683,8 @@ out:
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL rdpear_kerb_PackApReply(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
NdrContext* rcontext, wStream* s, UINT32* pstatus,
|
||||
PackApReplyResp* resp)
|
||||
static BOOL rdpear_kerb_PackApReply(RDPEAR_PLUGIN* rdpear, NdrContext* rcontext, wStream* s,
|
||||
UINT32* pstatus, PackApReplyResp* resp)
|
||||
{
|
||||
PackApReplyReq req = { 0 };
|
||||
krb5_data asn1Data = { 0 };
|
||||
|
@ -701,8 +721,7 @@ out:
|
|||
}
|
||||
|
||||
static UINT rdpear_decode_payload(RDPEAR_PLUGIN* rdpear,
|
||||
IWTSVirtualChannelCallback* pChannelCallback,
|
||||
RdpEarPackageType packageType, wStream* s)
|
||||
IWTSVirtualChannelCallback* pChannelCallback, wStream* s)
|
||||
{
|
||||
UINT ret = ERROR_INVALID_DATA;
|
||||
NdrContext* context = NULL;
|
||||
|
@ -724,8 +743,9 @@ static UINT rdpear_decode_payload(RDPEAR_PLUGIN* rdpear,
|
|||
|
||||
Stream_Seek(s, 16); /* skip first 16 bytes */
|
||||
|
||||
wStream commandStream;
|
||||
UINT16 callId, callId2;
|
||||
wStream commandStream = { 0 };
|
||||
UINT16 callId = 0;
|
||||
UINT16 callId2 = 0;
|
||||
|
||||
context = ndr_read_header(s);
|
||||
if (!context || !ndr_read_constructed(context, s, &commandStream) ||
|
||||
|
@ -741,16 +761,14 @@ static UINT rdpear_decode_payload(RDPEAR_PLUGIN* rdpear,
|
|||
resp = &uint32Resp;
|
||||
respDescr = ndr_uint32_descr();
|
||||
|
||||
if (rdpear_kerb_version(rdpear, pChannelCallback, context, &commandStream, &status,
|
||||
&uint32Resp))
|
||||
if (rdpear_kerb_version(context, &commandStream, &status, &uint32Resp))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
case RemoteCallKerbCreateApReqAuthenticator:
|
||||
resp = &createApReqAuthenticatorResp;
|
||||
respDescr = ndr_CreateApReqAuthenticatorResp_descr();
|
||||
|
||||
if (rdpear_kerb_CreateApReqAuthenticator(rdpear, pChannelCallback, context,
|
||||
&commandStream, &status,
|
||||
if (rdpear_kerb_CreateApReqAuthenticator(rdpear, context, &commandStream, &status,
|
||||
&createApReqAuthenticatorResp))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
|
@ -758,40 +776,37 @@ static UINT rdpear_decode_payload(RDPEAR_PLUGIN* rdpear,
|
|||
resp = &asn1Data;
|
||||
respDescr = ndr_KERB_ASN1_DATA_descr();
|
||||
|
||||
if (rdpear_kerb_DecryptApReply(rdpear, pChannelCallback, context, &commandStream,
|
||||
&status, &asn1Data))
|
||||
if (rdpear_kerb_DecryptApReply(rdpear, context, &commandStream, &status, &asn1Data))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
case RemoteCallKerbComputeTgsChecksum:
|
||||
resp = &asn1Data;
|
||||
respDescr = ndr_KERB_ASN1_DATA_descr();
|
||||
|
||||
if (rdpear_kerb_ComputeTgsChecksum(rdpear, pChannelCallback, context, &commandStream,
|
||||
&status, &asn1Data))
|
||||
if (rdpear_kerb_ComputeTgsChecksum(rdpear, context, &commandStream, &status, &asn1Data))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
case RemoteCallKerbBuildEncryptedAuthData:
|
||||
resp = &asn1Data;
|
||||
respDescr = ndr_KERB_ASN1_DATA_descr();
|
||||
|
||||
if (rdpear_kerb_BuildEncryptedAuthData(rdpear, pChannelCallback, context,
|
||||
&commandStream, &status, &asn1Data))
|
||||
if (rdpear_kerb_BuildEncryptedAuthData(rdpear, context, &commandStream, &status,
|
||||
&asn1Data))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
case RemoteCallKerbUnpackKdcReplyBody:
|
||||
resp = &unpackKdcReplyBodyResp;
|
||||
respDescr = ndr_UnpackKdcReplyBodyResp_descr();
|
||||
|
||||
if (rdpear_kerb_UnpackKdcReplyBody(rdpear, pChannelCallback, context, &commandStream,
|
||||
&status, &unpackKdcReplyBodyResp))
|
||||
if (rdpear_kerb_UnpackKdcReplyBody(rdpear, context, &commandStream, &status,
|
||||
&unpackKdcReplyBodyResp))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
case RemoteCallKerbPackApReply:
|
||||
resp = &packApReplyResp;
|
||||
respDescr = ndr_PackApReplyResp_descr();
|
||||
|
||||
if (rdpear_kerb_PackApReply(rdpear, pChannelCallback, context, &commandStream, &status,
|
||||
&packApReplyResp))
|
||||
if (rdpear_kerb_PackApReply(rdpear, context, &commandStream, &status, &packApReplyResp))
|
||||
ret = CHANNEL_RC_OK;
|
||||
break;
|
||||
|
||||
|
@ -855,7 +870,9 @@ static UINT rdpear_on_data_received(IWTSVirtualChannelCallback* pChannelCallback
|
|||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 24))
|
||||
return ERROR_INVALID_DATA;
|
||||
|
||||
UINT32 protocolMagic, Length, Version;
|
||||
UINT32 protocolMagic = 0;
|
||||
UINT32 Length = 0;
|
||||
UINT32 Version = 0;
|
||||
Stream_Read_UINT32(s, protocolMagic);
|
||||
if (protocolMagic != 0x4EACC3C8)
|
||||
return ERROR_INVALID_DATA;
|
||||
|
@ -880,29 +897,28 @@ static UINT rdpear_on_data_received(IWTSVirtualChannelCallback* pChannelCallback
|
|||
if (!freerdp_nla_decrypt(rdpear->rdp_context, &inBuffer, &decrypted))
|
||||
goto out;
|
||||
|
||||
WinPrAsn1Decoder dec, dec2;
|
||||
wStream decodedStream;
|
||||
WinPrAsn1Decoder dec = { 0 };
|
||||
WinPrAsn1Decoder dec2 = { 0 };
|
||||
wStream decodedStream = { 0 };
|
||||
Stream_StaticInit(&decodedStream, decrypted.pvBuffer, decrypted.cbBuffer);
|
||||
WinPrAsn1Decoder_Init(&dec, WINPR_ASN1_DER, &decodedStream);
|
||||
|
||||
if (!WinPrAsn1DecReadSequence(&dec, &dec2))
|
||||
goto out;
|
||||
|
||||
WinPrAsn1_OctetString packageName;
|
||||
WinPrAsn1_OctetString payload;
|
||||
BOOL error;
|
||||
WinPrAsn1_OctetString packageName = { 0 };
|
||||
WinPrAsn1_OctetString payload = { 0 };
|
||||
BOOL error = 0;
|
||||
if (!WinPrAsn1DecReadContextualOctetString(&dec2, 1, &error, &packageName, FALSE))
|
||||
goto out;
|
||||
|
||||
RdpEarPackageType packageType = rdpear_packageType_from_name(&packageName);
|
||||
|
||||
if (!WinPrAsn1DecReadContextualOctetString(&dec2, 2, &error, &payload, FALSE))
|
||||
goto out;
|
||||
|
||||
wStream payloadStream;
|
||||
wStream payloadStream = { 0 };
|
||||
Stream_StaticInit(&payloadStream, payload.data, payload.len);
|
||||
|
||||
ret = rdpear_decode_payload(rdpear, pChannelCallback, packageType, &payloadStream);
|
||||
ret = rdpear_decode_payload(rdpear, pChannelCallback, &payloadStream);
|
||||
out:
|
||||
sspi_SecBufferFree(&decrypted);
|
||||
return ret;
|
||||
|
@ -915,7 +931,7 @@ out:
|
|||
*/
|
||||
static UINT rdpear_on_open(IWTSVirtualChannelCallback* pChannelCallback)
|
||||
{
|
||||
|
||||
WINPR_UNUSED(pChannelCallback);
|
||||
return CHANNEL_RC_OK;
|
||||
}
|
||||
|
||||
|
@ -926,8 +942,8 @@ static UINT rdpear_on_open(IWTSVirtualChannelCallback* pChannelCallback)
|
|||
*/
|
||||
static UINT rdpear_on_close(IWTSVirtualChannelCallback* pChannelCallback)
|
||||
{
|
||||
UINT error = CHANNEL_RC_OK;
|
||||
return error;
|
||||
WINPR_UNUSED(pChannelCallback);
|
||||
return CHANNEL_RC_OK;
|
||||
}
|
||||
|
||||
static void terminate_plugin_cb(GENERIC_DYNVC_PLUGIN* base)
|
||||
|
@ -941,6 +957,7 @@ static void terminate_plugin_cb(GENERIC_DYNVC_PLUGIN* base)
|
|||
static UINT init_plugin_cb(GENERIC_DYNVC_PLUGIN* base, rdpContext* rcontext, rdpSettings* settings)
|
||||
{
|
||||
WINPR_ASSERT(base);
|
||||
WINPR_UNUSED(settings);
|
||||
|
||||
RDPEAR_PLUGIN* rdpear = (RDPEAR_PLUGIN*)base;
|
||||
rdpear->rdp_context = rcontext;
|
||||
|
@ -950,7 +967,8 @@ static UINT init_plugin_cb(GENERIC_DYNVC_PLUGIN* base, rdpContext* rcontext, rdp
|
|||
}
|
||||
|
||||
static const IWTSVirtualChannelCallback rdpear_callbacks = { rdpear_on_data_received,
|
||||
rdpear_on_open, rdpear_on_close };
|
||||
rdpear_on_open, rdpear_on_close,
|
||||
NULL };
|
||||
|
||||
/**
|
||||
* Function description
|
||||
|
|
|
@ -29,7 +29,6 @@
|
|||
#define NDR_MAX_CONSTRUCTS 16
|
||||
#define NDR_MAX_DEFERRED 50
|
||||
|
||||
/** @brief */
|
||||
struct NdrContext_s
|
||||
{
|
||||
BYTE version;
|
||||
|
@ -104,25 +103,22 @@ NdrContext* ndr_context_copy(const NdrContext* src)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void ndr_context_destroy(NdrContext** pcontext)
|
||||
void ndr_context_free(NdrContext* context)
|
||||
{
|
||||
WINPR_ASSERT(pcontext);
|
||||
|
||||
NdrContext* context = *pcontext;
|
||||
if (context)
|
||||
{
|
||||
HashTable_Free(context->refPointers);
|
||||
free(context);
|
||||
}
|
||||
*pcontext = NULL;
|
||||
}
|
||||
|
||||
void ndr_context_bytes_read(NdrContext* context, size_t len)
|
||||
static void ndr_context_bytes_read(NdrContext* context, size_t len)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
context->indentLevels[context->currentLevel] += len;
|
||||
}
|
||||
|
||||
void ndr_context_bytes_written(NdrContext* context, size_t len)
|
||||
static void ndr_context_bytes_written(NdrContext* context, size_t len)
|
||||
{
|
||||
ndr_context_bytes_read(context, len);
|
||||
}
|
||||
|
@ -132,12 +128,9 @@ NdrContext* ndr_read_header(wStream* s)
|
|||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
|
||||
return NULL;
|
||||
|
||||
BYTE version, drep;
|
||||
Stream_Read_UINT8(s, version);
|
||||
Stream_Read_UINT8(s, drep);
|
||||
|
||||
UINT16 headerLen;
|
||||
Stream_Read_UINT16(s, headerLen);
|
||||
BYTE version = Stream_Get_UINT8(s);
|
||||
BYTE drep = Stream_Get_UINT8(s);
|
||||
UINT16 headerLen = Stream_Get_UINT16(s);
|
||||
|
||||
if (headerLen < 4 || !Stream_CheckAndLogRequiredLength(TAG, s, headerLen - 4))
|
||||
return NULL;
|
||||
|
@ -163,6 +156,7 @@ BOOL ndr_write_header(NdrContext* context, wStream* s)
|
|||
Stream_Write(s, filler, sizeof(filler));
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL ndr_skip_bytes(NdrContext* context, wStream* s, size_t nbytes)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
|
@ -216,7 +210,7 @@ BOOL ndr_read_pickle(NdrContext* context, wStream* s)
|
|||
{
|
||||
WINPR_ASSERT(context);
|
||||
|
||||
UINT32 v;
|
||||
UINT32 v = 0;
|
||||
|
||||
/* NDR format label */
|
||||
if (!ndr_read_uint32(context, s, &v) || v != 0x20000)
|
||||
|
@ -241,7 +235,7 @@ BOOL ndr_read_constructed(NdrContext* context, wStream* s, wStream* target)
|
|||
{
|
||||
WINPR_ASSERT(context);
|
||||
|
||||
UINT32 len;
|
||||
UINT32 len = 0;
|
||||
|
||||
/* len */
|
||||
if (!ndr_read_uint32(context, s, &len))
|
||||
|
@ -280,16 +274,19 @@ BOOL ndr_start_constructed(NdrContext* context, wStream* s)
|
|||
BOOL ndr_end_constructed(NdrContext* context, wStream* s)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
WINPR_ASSERT(context->constructs);
|
||||
WINPR_ASSERT(context->constructLevel >= 0);
|
||||
|
||||
size_t offset = context->constructs[context->constructLevel];
|
||||
|
||||
wStream staticS;
|
||||
wStream staticS = { 0 };
|
||||
Stream_StaticInit(&staticS, Stream_Buffer(s) + offset, 4);
|
||||
|
||||
/* len */
|
||||
size_t len = Stream_GetPosition(s) - (offset + 8);
|
||||
if (!ndr_write_uint32(context, &staticS, len))
|
||||
const size_t len = Stream_GetPosition(s) - (offset + 8);
|
||||
if (len > UINT32_MAX)
|
||||
return FALSE;
|
||||
if (!ndr_write_uint32(context, &staticS, (UINT32)len))
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
|
@ -315,11 +312,6 @@ static size_t ndr_hintsCount(NdrMessageType msgType, const void* hints)
|
|||
}
|
||||
}
|
||||
|
||||
void Stream_Write_UINT64_BE(wStream* _s, UINT64 _v)
|
||||
{
|
||||
WINPR_ASSERT(FALSE && "implement Stream_Write_UINT64_BE()");
|
||||
}
|
||||
|
||||
BOOL ndr_read_uint8(NdrContext* context, wStream* s, BYTE* v)
|
||||
{
|
||||
WINPR_ASSERT(context);
|
||||
|
@ -335,6 +327,7 @@ BOOL ndr_read_uint8(NdrContext* context, wStream* s, BYTE* v)
|
|||
|
||||
BOOL ndr_read_uint8_(NdrContext* context, wStream* s, const void* hints, void* v)
|
||||
{
|
||||
WINPR_UNUSED(hints);
|
||||
return ndr_read_uint8(context, s, (BYTE*)v);
|
||||
}
|
||||
|
||||
|
@ -353,6 +346,7 @@ BOOL ndr_write_uint8_(NdrContext* context, wStream* s, const void* hints, const
|
|||
WINPR_ASSERT(context);
|
||||
WINPR_ASSERT(s);
|
||||
WINPR_ASSERT(v);
|
||||
WINPR_UNUSED(hints);
|
||||
|
||||
return ndr_write_uint8(context, s, *(const BYTE*)v);
|
||||
}
|
||||
|
@ -387,6 +381,7 @@ NdrMessageType ndr_uint8_descr(void)
|
|||
\
|
||||
BOOL ndr_read_##LOWERTYPE##_(NdrContext* context, wStream* s, const void* hints, void* v) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_read_##LOWERTYPE(context, s, (UPPERTYPE*)v); \
|
||||
} \
|
||||
\
|
||||
|
@ -411,14 +406,17 @@ NdrMessageType ndr_uint8_descr(void)
|
|||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(s); \
|
||||
WINPR_ASSERT(v); \
|
||||
WINPR_UNUSED(hints); \
|
||||
\
|
||||
return ndr_write_##LOWERTYPE(context, s, *(const UPPERTYPE*)v); \
|
||||
} \
|
||||
\
|
||||
const NdrMessageDescr ndr_##LOWERTYPE##_descr_s = { \
|
||||
NDR_ARITY_SIMPLE, sizeof(UPPERTYPE), ndr_read_##LOWERTYPE##_, \
|
||||
ndr_write_##LOWERTYPE##_, (NDR_DESTROY_FN)NULL, (NDR_DUMP_FN)NULL \
|
||||
}; \
|
||||
const NdrMessageDescr ndr_##LOWERTYPE##_descr_s = { NDR_ARITY_SIMPLE, \
|
||||
sizeof(UPPERTYPE), \
|
||||
ndr_read_##LOWERTYPE##_, \
|
||||
ndr_write_##LOWERTYPE##_, \
|
||||
NULL, \
|
||||
NULL }; \
|
||||
\
|
||||
NdrMessageType ndr_##LOWERTYPE##_descr(void) \
|
||||
{ \
|
||||
|
@ -435,8 +433,7 @@ SIMPLE_TYPE_IMPL(UINT64, uint64)
|
|||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(s); \
|
||||
WINPR_ASSERT(hints); \
|
||||
return ndr_read_uconformant_array(context, s, (NdrArrayHints*)hints, ndr_##TYPE##_descr(), \
|
||||
(void*)v); \
|
||||
return ndr_read_uconformant_array(context, s, hints, ndr_##TYPE##_descr(), v); \
|
||||
} \
|
||||
\
|
||||
BOOL ndr_write_##TYPE##Array(NdrContext* context, wStream* s, const void* hints, \
|
||||
|
@ -445,16 +442,15 @@ SIMPLE_TYPE_IMPL(UINT64, uint64)
|
|||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(s); \
|
||||
WINPR_ASSERT(hints); \
|
||||
NdrArrayHints* ahints = (NdrArrayHints*)hints; \
|
||||
return ndr_write_uconformant_array(context, s, ahints->count, ndr_##TYPE##_descr(), \
|
||||
(const void*)v); \
|
||||
const NdrArrayHints* ahints = (const NdrArrayHints*)hints; \
|
||||
return ndr_write_uconformant_array(context, s, ahints->count, ndr_##TYPE##_descr(), v); \
|
||||
} \
|
||||
void ndr_destroy_##TYPE##Array(NdrContext* context, const void* hints, void* obj) \
|
||||
{ \
|
||||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(obj); \
|
||||
WINPR_ASSERT(hints); \
|
||||
NdrArrayHints* ahints = (NdrArrayHints*)hints; \
|
||||
const NdrArrayHints* ahints = (const NdrArrayHints*)hints; \
|
||||
NdrMessageType descr = ndr_##TYPE##_descr(); \
|
||||
if (descr->destroyFn) \
|
||||
{ \
|
||||
|
@ -466,7 +462,7 @@ SIMPLE_TYPE_IMPL(UINT64, uint64)
|
|||
\
|
||||
const NdrMessageDescr ndr_##TYPE##Array_descr_s = { \
|
||||
NDR_ARITY_ARRAYOF, sizeof(UPPERTYPE), ndr_read_##TYPE##Array, \
|
||||
ndr_write_##TYPE##Array, ndr_destroy_##TYPE##Array, (NDR_DUMP_FN)NULL \
|
||||
ndr_write_##TYPE##Array, ndr_destroy_##TYPE##Array, NULL \
|
||||
}; \
|
||||
\
|
||||
NdrMessageType ndr_##TYPE##Array_descr(void) \
|
||||
|
@ -480,7 +476,7 @@ SIMPLE_TYPE_IMPL(UINT64, uint64)
|
|||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(s); \
|
||||
WINPR_ASSERT(hints); \
|
||||
return ndr_read_uconformant_varying_array(context, s, (NdrVaryingArrayHints*)hints, \
|
||||
return ndr_read_uconformant_varying_array(context, s, (const NdrVaryingArrayHints*)hints, \
|
||||
ndr_##TYPE##_descr(), v); \
|
||||
} \
|
||||
BOOL ndr_write_##TYPE##VaryingArray(NdrContext* context, wStream* s, const void* hints, \
|
||||
|
@ -489,14 +485,16 @@ SIMPLE_TYPE_IMPL(UINT64, uint64)
|
|||
WINPR_ASSERT(context); \
|
||||
WINPR_ASSERT(s); \
|
||||
WINPR_ASSERT(hints); \
|
||||
return ndr_write_uconformant_varying_array(context, s, (NdrVaryingArrayHints*)hints, \
|
||||
return ndr_write_uconformant_varying_array(context, s, (const NdrVaryingArrayHints*)hints, \
|
||||
ndr_##TYPE##_descr(), v); \
|
||||
} \
|
||||
\
|
||||
const NdrMessageDescr ndr_##TYPE##VaryingArray_descr_s = { \
|
||||
NDR_ARITY_VARYING_ARRAYOF, sizeof(UPPERTYPE), ndr_read_##TYPE##VaryingArray, \
|
||||
ndr_write_##TYPE##VaryingArray, (NDR_DESTROY_FN)NULL, (NDR_DUMP_FN)NULL \
|
||||
}; \
|
||||
const NdrMessageDescr ndr_##TYPE##VaryingArray_descr_s = { NDR_ARITY_VARYING_ARRAYOF, \
|
||||
sizeof(UPPERTYPE), \
|
||||
ndr_read_##TYPE##VaryingArray, \
|
||||
ndr_write_##TYPE##VaryingArray, \
|
||||
NULL, \
|
||||
NULL }; \
|
||||
\
|
||||
NdrMessageType ndr_##TYPE##VaryingArray_descr(void) \
|
||||
{ \
|
||||
|
@ -521,7 +519,9 @@ BOOL ndr_read_uconformant_varying_array(NdrContext* context, wStream* s,
|
|||
WINPR_ASSERT(itemType);
|
||||
WINPR_ASSERT(ptarget);
|
||||
|
||||
UINT32 maxCount, offset, length;
|
||||
UINT32 maxCount = 0;
|
||||
UINT32 offset = 0;
|
||||
UINT32 length = 0;
|
||||
|
||||
if (!ndr_read_uint32(context, s, &maxCount) || !ndr_read_uint32(context, s, &offset) ||
|
||||
!ndr_read_uint32(context, s, &length))
|
||||
|
@ -575,7 +575,7 @@ BOOL ndr_read_uconformant_array(NdrContext* context, wStream* s, const NdrArrayH
|
|||
WINPR_ASSERT(itemType);
|
||||
WINPR_ASSERT(vtarget);
|
||||
|
||||
UINT32 count;
|
||||
UINT32 count = 0;
|
||||
|
||||
if (!ndr_read_uint32(context, s, &count))
|
||||
return FALSE;
|
||||
|
@ -642,7 +642,7 @@ BOOL ndr_struct_read_fromDescr(NdrContext* context, wStream* s, const NdrStructD
|
|||
if (field->hintsField >= 0)
|
||||
{
|
||||
/* computes the address of the hints field if any */
|
||||
WINPR_ASSERT(field->hintsField < descr->nfields);
|
||||
WINPR_ASSERT((size_t)field->hintsField < descr->nfields);
|
||||
const NdrFieldStruct* hintsField = &descr->fields[field->hintsField];
|
||||
|
||||
hints = (BYTE*)target + hintsField->structOffset;
|
||||
|
@ -710,17 +710,17 @@ BOOL ndr_struct_write_fromDescr(NdrContext* context, wStream* s, const NdrStruct
|
|||
for (size_t i = 0; i < descr->nfields; i++)
|
||||
{
|
||||
const NdrFieldStruct* field = &descr->fields[i];
|
||||
BYTE* ptr = (BYTE*)src + field->structOffset;
|
||||
const BYTE* ptr = (const BYTE*)src + field->structOffset;
|
||||
|
||||
void* hints = NULL;
|
||||
const void* hints = NULL;
|
||||
|
||||
if (field->hintsField >= 0)
|
||||
{
|
||||
/* computes the address of the hints field if any */
|
||||
WINPR_ASSERT(field->hintsField < descr->nfields);
|
||||
WINPR_ASSERT((size_t)field->hintsField < descr->nfields);
|
||||
const NdrFieldStruct* hintsField = &descr->fields[field->hintsField];
|
||||
|
||||
hints = (BYTE*)src + hintsField->structOffset;
|
||||
hints = (const BYTE*)src + hintsField->structOffset;
|
||||
}
|
||||
|
||||
switch (field->pointerType)
|
||||
|
@ -729,8 +729,8 @@ BOOL ndr_struct_write_fromDescr(NdrContext* context, wStream* s, const NdrStruct
|
|||
case NDR_POINTER_NON_NULL:
|
||||
{
|
||||
ndr_refid ptrId = NDR_PTR_NULL;
|
||||
BOOL isNew;
|
||||
ptr = *(void**)ptr;
|
||||
BOOL isNew = 0;
|
||||
ptr = *(WINPR_CAST_CONST_PTR_AWAY(ptr, const void**));
|
||||
|
||||
if (!ptr && field->pointerType == NDR_POINTER_NON_NULL)
|
||||
{
|
||||
|
@ -753,8 +753,8 @@ BOOL ndr_struct_write_fromDescr(NdrContext* context, wStream* s, const NdrStruct
|
|||
}
|
||||
|
||||
deferred->name = field->name;
|
||||
deferred->hints = hints;
|
||||
deferred->target = ptr;
|
||||
deferred->hints = WINPR_CAST_CONST_PTR_AWAY(hints, void*);
|
||||
deferred->target = WINPR_CAST_CONST_PTR_AWAY(ptr, void*);
|
||||
deferred->msg = field->typeDescr;
|
||||
ndeferred++;
|
||||
}
|
||||
|
@ -791,13 +791,13 @@ void ndr_struct_dump_fromDescr(wLog* logger, UINT32 lvl, size_t identLevel,
|
|||
for (size_t i = 0; i < descr->nfields; i++)
|
||||
{
|
||||
const NdrFieldStruct* field = &descr->fields[i];
|
||||
BYTE* ptr = (BYTE*)obj + field->structOffset;
|
||||
const BYTE* ptr = (const BYTE*)obj + field->structOffset;
|
||||
|
||||
switch (field->pointerType)
|
||||
{
|
||||
case NDR_POINTER:
|
||||
case NDR_POINTER_NON_NULL:
|
||||
ptr = *(void**)ptr;
|
||||
ptr = *(WINPR_CAST_CONST_PTR_AWAY(ptr, const void**));
|
||||
break;
|
||||
case NDR_NOT_POINTER:
|
||||
break;
|
||||
|
@ -829,7 +829,7 @@ void ndr_struct_destroy(NdrContext* context, const NdrStructDescr* descr, void*
|
|||
if (field->hintsField >= 0)
|
||||
{
|
||||
/* computes the address of the hints field if any */
|
||||
WINPR_ASSERT(field->hintsField < descr->nfields);
|
||||
WINPR_ASSERT((size_t)field->hintsField < descr->nfields);
|
||||
const NdrFieldStruct* hintsField = &descr->fields[field->hintsField];
|
||||
|
||||
hints = (BYTE*)pptr + hintsField->structOffset;
|
||||
|
@ -862,7 +862,7 @@ typedef struct
|
|||
ndr_refid* presult;
|
||||
} FindValueArgs;
|
||||
|
||||
BOOL findValueRefFn(const void* key, void* value, void* parg)
|
||||
static BOOL findValueRefFn(const void* key, void* value, void* parg)
|
||||
{
|
||||
WINPR_ASSERT(parg);
|
||||
|
||||
|
|
|
@ -23,6 +23,31 @@
|
|||
#include <winpr/stream.h>
|
||||
#include <freerdp/api.h>
|
||||
|
||||
#define NDR_PTR_NULL (0UL)
|
||||
|
||||
#define NDR_SIMPLE_TYPE_DECL(LOWER, UPPER) \
|
||||
BOOL ndr_read_##LOWER(NdrContext* context, wStream* s, UPPER* v); \
|
||||
BOOL ndr_read_##LOWER##_(NdrContext* context, wStream* s, const void* hints, void* v); \
|
||||
BOOL ndr_write_##LOWER(NdrContext* context, wStream* s, UPPER v); \
|
||||
BOOL ndr_write_##LOWER##_(NdrContext* context, wStream* s, const void* hints, const void* v); \
|
||||
extern const NdrMessageDescr ndr_##LOWER##_descr_s; \
|
||||
NdrMessageType ndr_##LOWER##_descr(void)
|
||||
|
||||
#define NDR_ARRAY_OF_TYPE_DECL(TYPE, UPPERTYPE) \
|
||||
BOOL ndr_read_##TYPE##Array(NdrContext* context, wStream* s, const void* hints, void* v); \
|
||||
BOOL ndr_write_##TYPE##Array(NdrContext* context, wStream* s, const void* hints, \
|
||||
const void* v); \
|
||||
void ndr_destroy_##TYPE##Array(NdrContext* context, const void* hints, void* obj); \
|
||||
extern const NdrMessageDescr ndr_##TYPE##Array_descr_s; \
|
||||
NdrMessageType ndr_##TYPE##Array_descr(void); \
|
||||
\
|
||||
BOOL ndr_read_##TYPE##VaryingArray(NdrContext* context, wStream* s, const void* hints, \
|
||||
void* v); \
|
||||
BOOL ndr_write_##TYPE##VaryingArray(NdrContext* context, wStream* s, const void* hints, \
|
||||
const void* v); \
|
||||
extern const NdrMessageDescr ndr_##TYPE##VaryingArray_descr_s; \
|
||||
NdrMessageType ndr_##TYPE##VaryingArray_descr(void)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
|
@ -31,7 +56,6 @@ extern "C"
|
|||
typedef struct NdrContext_s NdrContext;
|
||||
|
||||
typedef UINT32 ndr_refid;
|
||||
#define NDR_PTR_NULL (0UL)
|
||||
|
||||
typedef BOOL (*NDR_READER_FN)(NdrContext* context, wStream* s, const void* hints, void* target);
|
||||
typedef BOOL (*NDR_WRITER_FN)(NdrContext* context, wStream* s, const void* hints,
|
||||
|
@ -96,34 +120,35 @@ extern "C"
|
|||
NdrMessageType msg;
|
||||
} NdrDeferredEntry;
|
||||
|
||||
void ndr_context_free(NdrContext* context);
|
||||
|
||||
static INLINE void ndr_context_destroy(NdrContext** pcontext)
|
||||
{
|
||||
WINPR_ASSERT(pcontext);
|
||||
ndr_context_free(*pcontext);
|
||||
*pcontext = NULL;
|
||||
}
|
||||
|
||||
WINPR_ATTR_MALLOC(ndr_context_free, 1)
|
||||
NdrContext* ndr_context_new(BOOL bigEndianDrep, BYTE version);
|
||||
void ndr_context_destroy(NdrContext** pcontext);
|
||||
|
||||
void ndr_context_reset(NdrContext* context);
|
||||
|
||||
WINPR_ATTR_MALLOC(ndr_context_free, 1)
|
||||
NdrContext* ndr_context_copy(const NdrContext* src);
|
||||
|
||||
WINPR_ATTR_MALLOC(ndr_context_free, 1)
|
||||
NdrContext* ndr_read_header(wStream* s);
|
||||
|
||||
BOOL ndr_write_header(NdrContext* context, wStream* s);
|
||||
|
||||
BOOL ndr_write_uint8(NdrContext* context, wStream* s, BYTE v);
|
||||
BOOL ndr_write_uint8_(NdrContext* context, wStream* s, const void* hints, const void* v);
|
||||
NdrMessageType ndr_uint8_descr(void);
|
||||
|
||||
#define NDR_SIMPLE_TYPE_DECL(LOWER, UPPER) \
|
||||
BOOL ndr_read_##LOWER(NdrContext* context, wStream* s, UPPER* v); \
|
||||
BOOL ndr_write_##LOWER(NdrContext* context, wStream* s, UPPER v); \
|
||||
BOOL ndr_write_##LOWER##_(NdrContext* context, wStream* s, const void* hints, const void* v); \
|
||||
extern const NdrMessageDescr ndr_##LOWER##_descr_s; \
|
||||
NdrMessageType ndr_##LOWER##_descr(void)
|
||||
|
||||
NDR_SIMPLE_TYPE_DECL(uint8, UINT8);
|
||||
NDR_SIMPLE_TYPE_DECL(uint16, UINT16);
|
||||
NDR_SIMPLE_TYPE_DECL(uint32, UINT32);
|
||||
NDR_SIMPLE_TYPE_DECL(uint64, UINT64);
|
||||
|
||||
extern const NdrMessageDescr ndr_uint8Array_descr_s;
|
||||
NdrMessageType ndr_uint8Array_descr(void);
|
||||
NdrMessageType ndr_uint16Array_descr(void);
|
||||
NdrMessageType ndr_uint16VaryingArray_descr(void);
|
||||
NDR_ARRAY_OF_TYPE_DECL(uint8, BYTE);
|
||||
NDR_ARRAY_OF_TYPE_DECL(uint16, UINT16);
|
||||
|
||||
BOOL ndr_skip_bytes(NdrContext* context, wStream* s, size_t nbytes);
|
||||
BOOL ndr_read_align(NdrContext* context, wStream* s, size_t sz);
|
||||
|
|
|
@ -88,7 +88,7 @@ FREERDP_LOCAL wStream* rdpear_encodePayload(RdpEarPackageType packageType, wStre
|
|||
const V* obj); \
|
||||
FREERDP_LOCAL void ndr_destroy_##V(NdrContext* context, const void* hints, V* obj); \
|
||||
FREERDP_LOCAL void ndr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const V* obj); \
|
||||
FREERDP_LOCAL NdrMessageType ndr_##V##_descr()
|
||||
FREERDP_LOCAL NdrMessageType ndr_##V##_descr(void)
|
||||
|
||||
/** @brief 2.2.1.2.2 KERB_RPC_OCTET_STRING */
|
||||
typedef struct
|
||||
|
@ -127,15 +127,7 @@ typedef struct
|
|||
RPC_UNICODE_STRING* Names;
|
||||
} KERB_RPC_INTERNAL_NAME;
|
||||
|
||||
FREERDP_LOCAL BOOL ndr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s,
|
||||
const void* hints, KERB_RPC_INTERNAL_NAME* res);
|
||||
FREERDP_LOCAL BOOL ndr_write_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s,
|
||||
const void* hints,
|
||||
const KERB_RPC_INTERNAL_NAME* res);
|
||||
FREERDP_LOCAL void ndr_dump_KERB_RPC_INTERNAL_NAME(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const KERB_RPC_INTERNAL_NAME* obj);
|
||||
FREERDP_LOCAL void ndr_destroy_KERB_RPC_INTERNAL_NAME(NdrContext* context, const void* hints,
|
||||
KERB_RPC_INTERNAL_NAME* obj);
|
||||
RDPEAR_COMMON_MESSAGE_DECL(KERB_RPC_INTERNAL_NAME);
|
||||
|
||||
/** @brief 2.2.1.2.8 KERB_RPC_ENCRYPTION_KEY */
|
||||
typedef struct
|
||||
|
@ -191,7 +183,7 @@ typedef struct
|
|||
LONG KerbProtocolError;
|
||||
} CreateApReqAuthenticatorResp;
|
||||
|
||||
FREERDP_LOCAL NdrMessageType ndr_CreateApReqAuthenticatorResp_descr();
|
||||
RDPEAR_COMMON_MESSAGE_DECL(CreateApReqAuthenticatorResp);
|
||||
|
||||
/** @brief 2.2.2.1.6 UnpackKdcReplyBody */
|
||||
typedef struct
|
||||
|
@ -212,7 +204,7 @@ typedef struct
|
|||
KERB_ASN1_DATA ReplyBody;
|
||||
} UnpackKdcReplyBodyResp;
|
||||
|
||||
FREERDP_LOCAL NdrMessageType ndr_UnpackKdcReplyBodyResp_descr();
|
||||
RDPEAR_COMMON_MESSAGE_DECL(UnpackKdcReplyBodyResp);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
@ -237,7 +229,7 @@ typedef struct
|
|||
BYTE* PackedReply;
|
||||
} PackApReplyResp;
|
||||
|
||||
FREERDP_LOCAL NdrMessageType ndr_PackApReplyResp_descr();
|
||||
RDPEAR_COMMON_MESSAGE_DECL(PackApReplyResp);
|
||||
|
||||
#undef RDPEAR_COMMON_MESSAGE_DECL
|
||||
|
||||
|
|
|
@ -26,10 +26,10 @@
|
|||
|
||||
#define TAG CHANNELS_TAG("rdpear")
|
||||
|
||||
const char kerberosPackageName[] = {
|
||||
static char kerberosPackageName[] = {
|
||||
'K', 0, 'e', 0, 'r', 0, 'b', 0, 'e', 0, 'r', 0, 'o', 0, 's', 0
|
||||
};
|
||||
const char ntlmPackageName[] = { 'N', 0, 'T', 0, 'L', 0, 'M', 0 };
|
||||
static char ntlmPackageName[] = { 'N', 0, 'T', 0, 'L', 0, 'M', 0 };
|
||||
|
||||
RdpEarPackageType rdpear_packageType_from_name(WinPrAsn1_OctetString* package)
|
||||
{
|
||||
|
@ -99,36 +99,56 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
#define RDPEAR_SIMPLE_MESSAGE_TYPE(V) \
|
||||
BOOL ndr_read_##V(NdrContext* context, wStream* s, const void* hints, V* obj) \
|
||||
{ \
|
||||
return ndr_struct_read_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
BOOL ndr_write_##V(NdrContext* context, wStream* s, const void* hints, const V* obj) \
|
||||
{ \
|
||||
return ndr_struct_write_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_destroy_##V(NdrContext* context, const void* hints, V* obj) \
|
||||
{ \
|
||||
ndr_struct_destroy(context, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const V* obj) \
|
||||
{ \
|
||||
ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &V##_struct, obj); \
|
||||
} \
|
||||
\
|
||||
NdrMessageDescr ndr_##V##_descr_s = { \
|
||||
NDR_ARITY_SIMPLE, \
|
||||
sizeof(V), \
|
||||
(NDR_READER_FN)ndr_read_##V, \
|
||||
(NDR_WRITER_FN)ndr_write_##V, \
|
||||
(NDR_DESTROY_FN)ndr_destroy_##V, \
|
||||
(NDR_DUMP_FN)ndr_dump_##V, \
|
||||
}; \
|
||||
\
|
||||
NdrMessageType ndr_##V##_descr(void) \
|
||||
{ \
|
||||
return &ndr_##V##_descr_s; \
|
||||
#define RDPEAR_SIMPLE_MESSAGE_TYPE(V) \
|
||||
BOOL ndr_read_##V(NdrContext* context, wStream* s, const void* hints, V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_read_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
BOOL ndr_write_##V(NdrContext* context, wStream* s, const void* hints, const V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_write_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_destroy_##V(NdrContext* context, const void* hints, V* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
ndr_struct_destroy(context, &V##_struct, obj); \
|
||||
} \
|
||||
void ndr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const V* obj) \
|
||||
{ \
|
||||
ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &V##_struct, obj); \
|
||||
} \
|
||||
\
|
||||
static BOOL ndr_descr_read_##V(NdrContext* context, wStream* s, const void* hints, void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_read_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
static BOOL ndr_descr_write_##V(NdrContext* context, wStream* s, const void* hints, \
|
||||
const void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
return ndr_struct_write_fromDescr(context, s, &V##_struct, obj); \
|
||||
} \
|
||||
static void ndr_descr_destroy_##V(NdrContext* context, const void* hints, void* obj) \
|
||||
{ \
|
||||
WINPR_UNUSED(hints); \
|
||||
ndr_struct_destroy(context, &V##_struct, obj); \
|
||||
} \
|
||||
static void ndr_descr_dump_##V(wLog* logger, UINT32 lvl, size_t indentLevel, const void* obj) \
|
||||
{ \
|
||||
ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &V##_struct, obj); \
|
||||
} \
|
||||
\
|
||||
static NdrMessageDescr ndr_##V##_descr_s = { \
|
||||
NDR_ARITY_SIMPLE, sizeof(V), ndr_descr_read_##V, ndr_descr_write_##V, \
|
||||
ndr_descr_destroy_##V, ndr_descr_dump_##V, \
|
||||
}; \
|
||||
\
|
||||
NdrMessageType ndr_##V##_descr(void) \
|
||||
{ \
|
||||
return &ndr_##V##_descr_s; \
|
||||
}
|
||||
|
||||
static const NdrFieldStruct KERB_RPC_OCTET_STRING_fields[] = {
|
||||
|
@ -163,8 +183,10 @@ BOOL ndr_read_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hi
|
|||
{
|
||||
NdrDeferredEntry bufferDesc = { NDR_PTR_NULL, "RPC_UNICODE_STRING.Buffer", &res->lenHints,
|
||||
&res->Buffer, ndr_uint16VaryingArray_descr() };
|
||||
UINT16 Length, MaximumLength;
|
||||
UINT16 Length = 0;
|
||||
UINT16 MaximumLength = 0;
|
||||
|
||||
WINPR_UNUSED(hints);
|
||||
if (!ndr_read_uint16(context, s, &Length) || !ndr_read_uint16(context, s, &MaximumLength) ||
|
||||
!ndr_read_refpointer(context, s, &bufferDesc.ptrId) || Length > MaximumLength)
|
||||
return FALSE;
|
||||
|
@ -176,6 +198,12 @@ BOOL ndr_read_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hi
|
|||
return ndr_push_deferreds(context, &bufferDesc, 1);
|
||||
}
|
||||
|
||||
static BOOL ndr_descr_read_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hints,
|
||||
void* res)
|
||||
{
|
||||
return ndr_read_RPC_UNICODE_STRING(context, s, hints, res);
|
||||
}
|
||||
|
||||
#if 0
|
||||
BOOL ndr_write_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* hints,
|
||||
const RPC_UNICODE_STRING* res)
|
||||
|
@ -190,31 +218,43 @@ BOOL ndr_write_RPC_UNICODE_STRING(NdrContext* context, wStream* s, const void* h
|
|||
void ndr_dump_RPC_UNICODE_STRING(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const RPC_UNICODE_STRING* obj)
|
||||
{
|
||||
WINPR_UNUSED(indentLevel);
|
||||
WLog_Print(logger, lvl, "\tLength=%d MaximumLength=%d", obj->lenHints.length,
|
||||
obj->lenHints.maxLength);
|
||||
winpr_HexLogDump(logger, lvl, obj->Buffer, obj->lenHints.length);
|
||||
}
|
||||
|
||||
static void ndr_descr_dump_RPC_UNICODE_STRING(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const void* obj)
|
||||
{
|
||||
ndr_dump_RPC_UNICODE_STRING(logger, lvl, indentLevel, obj);
|
||||
}
|
||||
|
||||
void ndr_destroy_RPC_UNICODE_STRING(NdrContext* context, const void* hints, RPC_UNICODE_STRING* obj)
|
||||
{
|
||||
WINPR_UNUSED(context);
|
||||
WINPR_UNUSED(hints);
|
||||
if (!obj)
|
||||
return;
|
||||
free(obj->Buffer);
|
||||
obj->Buffer = NULL;
|
||||
}
|
||||
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_descr_ = {
|
||||
NDR_ARITY_SIMPLE,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
(NDR_READER_FN)ndr_read_RPC_UNICODE_STRING,
|
||||
(NDR_WRITER_FN) /*ndr_write_RPC_UNICODE_STRING*/ NULL,
|
||||
(NDR_DESTROY_FN)ndr_destroy_RPC_UNICODE_STRING,
|
||||
(NDR_DUMP_FN)ndr_dump_RPC_UNICODE_STRING
|
||||
};
|
||||
|
||||
NdrMessageType RPC_UNICODE_STRING_descr()
|
||||
static void ndr_descr_destroy_RPC_UNICODE_STRING(NdrContext* context, const void* hints, void* obj)
|
||||
{
|
||||
return &RPC_UNICODE_STRING_descr_;
|
||||
ndr_destroy_RPC_UNICODE_STRING(context, hints, obj);
|
||||
}
|
||||
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_descr_s = { NDR_ARITY_SIMPLE,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
ndr_descr_read_RPC_UNICODE_STRING,
|
||||
/*ndr_write_RPC_UNICODE_STRING*/ NULL,
|
||||
ndr_descr_destroy_RPC_UNICODE_STRING,
|
||||
ndr_descr_dump_RPC_UNICODE_STRING };
|
||||
|
||||
NdrMessageType ndr_RPC_UNICODE_STRING_descr(void)
|
||||
{
|
||||
return &RPC_UNICODE_STRING_descr_s;
|
||||
}
|
||||
|
||||
/* ========================= RPC_UNICODE_STRING_Array ======================== */
|
||||
|
@ -225,7 +265,7 @@ static BOOL ndr_read_RPC_UNICODE_STRING_Array(NdrContext* context, wStream* s, c
|
|||
WINPR_ASSERT(context);
|
||||
WINPR_ASSERT(s);
|
||||
WINPR_ASSERT(hints);
|
||||
return ndr_read_uconformant_array(context, s, hints, RPC_UNICODE_STRING_descr(), v);
|
||||
return ndr_read_uconformant_array(context, s, hints, ndr_RPC_UNICODE_STRING_descr(), v);
|
||||
}
|
||||
|
||||
static BOOL ndr_write_RPC_UNICODE_STRING_Array(NdrContext* context, wStream* s, const void* ghints,
|
||||
|
@ -237,19 +277,21 @@ static BOOL ndr_write_RPC_UNICODE_STRING_Array(NdrContext* context, wStream* s,
|
|||
|
||||
const NdrArrayHints* hints = (const NdrArrayHints*)ghints;
|
||||
|
||||
return ndr_write_uconformant_array(context, s, hints->count, RPC_UNICODE_STRING_descr(), v);
|
||||
return ndr_write_uconformant_array(context, s, hints->count, ndr_RPC_UNICODE_STRING_descr(), v);
|
||||
}
|
||||
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_Array_descr_ = { NDR_ARITY_ARRAYOF,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
ndr_read_RPC_UNICODE_STRING_Array,
|
||||
ndr_write_RPC_UNICODE_STRING_Array,
|
||||
(NDR_DESTROY_FN)NULL,
|
||||
(NDR_DUMP_FN)NULL };
|
||||
static const NdrMessageDescr RPC_UNICODE_STRING_Array_descr_s = {
|
||||
NDR_ARITY_ARRAYOF,
|
||||
sizeof(RPC_UNICODE_STRING),
|
||||
ndr_read_RPC_UNICODE_STRING_Array,
|
||||
ndr_write_RPC_UNICODE_STRING_Array,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
NdrMessageType RPC_UNICODE_STRING_Array_descr()
|
||||
static NdrMessageType ndr_RPC_UNICODE_STRING_Array_descr(void)
|
||||
{
|
||||
return &RPC_UNICODE_STRING_Array_descr_;
|
||||
return &RPC_UNICODE_STRING_Array_descr_s;
|
||||
}
|
||||
|
||||
/* ========================== KERB_RPC_INTERNAL_NAME ======================== */
|
||||
|
@ -257,10 +299,20 @@ NdrMessageType RPC_UNICODE_STRING_Array_descr()
|
|||
BOOL ndr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s, const void* hints,
|
||||
KERB_RPC_INTERNAL_NAME* res)
|
||||
{
|
||||
NdrDeferredEntry names = { NDR_PTR_NULL, "KERB_RPC_INTERNAL_NAME.Names", &res->nameHints,
|
||||
&res->Names, RPC_UNICODE_STRING_Array_descr() };
|
||||
WINPR_ASSERT(res);
|
||||
|
||||
union
|
||||
{
|
||||
RPC_UNICODE_STRING** ppstr;
|
||||
void* pv;
|
||||
} cnv;
|
||||
cnv.ppstr = &res->Names;
|
||||
NdrDeferredEntry names = { NDR_PTR_NULL, "KERB_RPC_INTERNAL_NAME.Names", &res->nameHints,
|
||||
cnv.pv, ndr_RPC_UNICODE_STRING_Array_descr() };
|
||||
|
||||
UINT16 nameCount = 0;
|
||||
WINPR_UNUSED(hints);
|
||||
|
||||
UINT16 nameCount;
|
||||
if (!ndr_read_uint16(context, s, &res->NameType) || !ndr_read_uint16(context, s, &nameCount))
|
||||
return FALSE;
|
||||
|
||||
|
@ -269,42 +321,67 @@ BOOL ndr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s, const void
|
|||
return ndr_read_refpointer(context, s, &names.ptrId) && ndr_push_deferreds(context, &names, 1);
|
||||
}
|
||||
|
||||
static BOOL ndr_descr_read_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s,
|
||||
const void* hints, void* res)
|
||||
{
|
||||
return ndr_read_KERB_RPC_INTERNAL_NAME(context, s, hints, res);
|
||||
}
|
||||
|
||||
BOOL ndr_write_KERB_RPC_INTERNAL_NAME(NdrContext* context, wStream* s, const void* hints,
|
||||
const KERB_RPC_INTERNAL_NAME* res)
|
||||
{
|
||||
WINPR_UNUSED(context);
|
||||
WINPR_UNUSED(s);
|
||||
WINPR_UNUSED(hints);
|
||||
WINPR_UNUSED(res);
|
||||
WLog_ERR(TAG, "TODO: implement this");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void ndr_dump_KERB_RPC_INTERNAL_NAME(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const KERB_RPC_INTERNAL_NAME* obj)
|
||||
{
|
||||
WINPR_UNUSED(indentLevel);
|
||||
WINPR_UNUSED(obj);
|
||||
WLog_Print(logger, lvl, "TODO: implement this");
|
||||
}
|
||||
|
||||
static void ndr_descr_dump_KERB_RPC_INTERNAL_NAME(wLog* logger, UINT32 lvl, size_t indentLevel,
|
||||
const void* obj)
|
||||
{
|
||||
ndr_dump_KERB_RPC_INTERNAL_NAME(logger, lvl, indentLevel, obj);
|
||||
}
|
||||
|
||||
void ndr_destroy_KERB_RPC_INTERNAL_NAME(NdrContext* context, const void* hints,
|
||||
KERB_RPC_INTERNAL_NAME* obj)
|
||||
{
|
||||
WINPR_UNUSED(hints);
|
||||
if (!obj)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < obj->nameHints.count; i++)
|
||||
for (UINT32 i = 0; i < obj->nameHints.count; i++)
|
||||
ndr_destroy_RPC_UNICODE_STRING(context, NULL, &obj->Names[i]);
|
||||
|
||||
free(obj->Names);
|
||||
obj->Names = NULL;
|
||||
}
|
||||
|
||||
NdrMessageDescr KERB_RPC_INTERNAL_NAME_descr_ = {
|
||||
NDR_ARITY_SIMPLE,
|
||||
sizeof(KERB_RPC_INTERNAL_NAME),
|
||||
(NDR_READER_FN)ndr_read_KERB_RPC_INTERNAL_NAME,
|
||||
(NDR_WRITER_FN)NULL,
|
||||
(NDR_DESTROY_FN)ndr_destroy_KERB_RPC_INTERNAL_NAME,
|
||||
(NDR_DUMP_FN)ndr_dump_KERB_RPC_INTERNAL_NAME
|
||||
};
|
||||
|
||||
NdrMessageType KERB_RPC_INTERNAL_NAME_descr()
|
||||
static void ndr_descr_destroy_KERB_RPC_INTERNAL_NAME(NdrContext* context, const void* hints,
|
||||
void* obj)
|
||||
{
|
||||
return &KERB_RPC_INTERNAL_NAME_descr_;
|
||||
ndr_destroy_KERB_RPC_INTERNAL_NAME(context, hints, obj);
|
||||
}
|
||||
|
||||
static NdrMessageDescr KERB_RPC_INTERNAL_NAME_descr_s = { NDR_ARITY_SIMPLE,
|
||||
sizeof(KERB_RPC_INTERNAL_NAME),
|
||||
ndr_descr_read_KERB_RPC_INTERNAL_NAME,
|
||||
NULL,
|
||||
ndr_descr_destroy_KERB_RPC_INTERNAL_NAME,
|
||||
ndr_descr_dump_KERB_RPC_INTERNAL_NAME };
|
||||
|
||||
NdrMessageType ndr_KERB_RPC_INTERNAL_NAME_descr(void)
|
||||
{
|
||||
return &KERB_RPC_INTERNAL_NAME_descr_s;
|
||||
}
|
||||
|
||||
/* ========================== KERB_RPC_ENCRYPTION_KEY ======================== */
|
||||
|
@ -365,9 +442,9 @@ static const NdrFieldStruct CreateApReqAuthenticatorReq_fields[] = {
|
|||
{ "SequenceNumber", offsetof(CreateApReqAuthenticatorReq, SequenceNumber), NDR_NOT_POINTER, -1,
|
||||
&ndr_uint32_descr_s },
|
||||
{ "ClientName", offsetof(CreateApReqAuthenticatorReq, ClientName), NDR_POINTER_NON_NULL, -1,
|
||||
&KERB_RPC_INTERNAL_NAME_descr_ },
|
||||
&KERB_RPC_INTERNAL_NAME_descr_s },
|
||||
{ "ClientRealm", offsetof(CreateApReqAuthenticatorReq, ClientRealm), NDR_POINTER_NON_NULL, -1,
|
||||
&RPC_UNICODE_STRING_descr_ },
|
||||
&RPC_UNICODE_STRING_descr_s },
|
||||
{ "SkewTime", offsetof(CreateApReqAuthenticatorReq, SkewTime), NDR_POINTER_NON_NULL, -1,
|
||||
&ndr_uint64_descr_s },
|
||||
{ "SubKey", offsetof(CreateApReqAuthenticatorReq, SubKey), NDR_POINTER, -1,
|
||||
|
|
|
@ -4,6 +4,8 @@ set(MODULE_PREFIX "TEST_RDPEAR")
|
|||
|
||||
set(TEST_RDPEAR_DRIVER TestRdpear.c)
|
||||
|
||||
disable_warnings_for_directory(${CMAKE_CURRENT_BINARY_DIR})
|
||||
|
||||
set(TEST_RDPEAR_TESTS
|
||||
TestNdr.c
|
||||
TestNdrEar.c
|
||||
|
|
|
@ -2,6 +2,9 @@
|
|||
|
||||
int TestNdr(int argc, char* argv[])
|
||||
{
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
int retCode = -2;
|
||||
NdrContext* context = ndr_context_new(FALSE, 1);
|
||||
if (!context)
|
||||
|
|
|
@ -3,7 +3,22 @@
|
|||
#include <rdpear-common/ndr.h>
|
||||
#include <rdpear-common/rdpear_common.h>
|
||||
|
||||
BYTE* parseHexBlock(const char* str, size_t* plen)
|
||||
#ifndef MAX
|
||||
#define MAX(a, b) ((a) > (b)) ? (a) : (b)
|
||||
#endif
|
||||
#ifndef MIN
|
||||
#define MIN(a, b) ((a) < (b)) ? (a) : (b)
|
||||
#endif
|
||||
|
||||
static BYTE nextValue(BYTE old, INT32 offset, char symbol, char startSymbol)
|
||||
{
|
||||
const INT32 uold = 16 * old;
|
||||
const INT32 diff = symbol - startSymbol;
|
||||
const INT32 res = uold + diff + offset;
|
||||
return (BYTE)MIN(MAX(0, res), UINT8_MAX);
|
||||
}
|
||||
|
||||
static BYTE* parseHexBlock(const char* str, size_t* plen)
|
||||
{
|
||||
WINPR_ASSERT(str);
|
||||
WINPR_ASSERT(plen);
|
||||
|
@ -39,7 +54,7 @@ BYTE* parseHexBlock(const char* str, size_t* plen)
|
|||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
tmp = tmp * 16 + (*ptr - '0');
|
||||
tmp = nextValue(tmp, 0, *ptr, '0');
|
||||
nchars++;
|
||||
if (nchars == 2)
|
||||
{
|
||||
|
@ -57,7 +72,7 @@ BYTE* parseHexBlock(const char* str, size_t* plen)
|
|||
case 'd':
|
||||
case 'e':
|
||||
case 'f':
|
||||
tmp = tmp * 16 + (10 + *ptr - 'a');
|
||||
tmp = nextValue(tmp, 10, *ptr, 'a');
|
||||
nchars++;
|
||||
if (nchars == 2)
|
||||
{
|
||||
|
@ -75,7 +90,7 @@ BYTE* parseHexBlock(const char* str, size_t* plen)
|
|||
case 'D':
|
||||
case 'E':
|
||||
case 'F':
|
||||
tmp = tmp * 16 + (10 + *ptr - 'A');
|
||||
tmp = nextValue(tmp, 10, *ptr, 'A');
|
||||
nchars++;
|
||||
if (nchars == 2)
|
||||
{
|
||||
|
@ -97,36 +112,42 @@ BYTE* parseHexBlock(const char* str, size_t* plen)
|
|||
return ret;
|
||||
}
|
||||
|
||||
int TestNdrEarWrite(int argc, char* argv[])
|
||||
static int TestNdrEarWrite(int argc, char* argv[])
|
||||
{
|
||||
wStream* s = NULL;
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
int rc = -1;
|
||||
BYTE buffer[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
|
||||
KERB_ASN1_DATA asn1;
|
||||
asn1.Pdu = 7;
|
||||
asn1.Asn1BufferHints.count = 16;
|
||||
asn1.Asn1Buffer = buffer;
|
||||
KERB_ASN1_DATA asn1 = { 7, { 16 }, buffer };
|
||||
|
||||
s = Stream_New(NULL, 100);
|
||||
wStream* s = Stream_New(NULL, 100);
|
||||
if (!s)
|
||||
return -1;
|
||||
|
||||
NdrContext* context = ndr_context_new(FALSE, 1);
|
||||
if (!context)
|
||||
return -1;
|
||||
goto fail;
|
||||
|
||||
if (!ndr_write_KERB_ASN1_DATA(context, s, NULL, &asn1))
|
||||
return -2;
|
||||
goto fail;
|
||||
if (!ndr_treat_deferred_write(context, s))
|
||||
return -3;
|
||||
goto fail;
|
||||
|
||||
// winpr_HexDump("", WLOG_DEBUG, Stream_Buffer(s), Stream_GetPosition(s));
|
||||
|
||||
rc = 0;
|
||||
fail:
|
||||
ndr_context_destroy(&context);
|
||||
return 0;
|
||||
Stream_Free(s, TRUE);
|
||||
return rc;
|
||||
}
|
||||
|
||||
int TestNdrEarRead(int argc, char* argv[])
|
||||
static int TestNdrEarRead(int argc, char* argv[])
|
||||
{
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
int retCode = -2;
|
||||
|
||||
/* ====================================================================== */
|
||||
|
@ -134,8 +155,8 @@ int TestNdrEarRead(int argc, char* argv[])
|
|||
if (!context)
|
||||
return -1;
|
||||
|
||||
wStream staticS;
|
||||
wStream* s;
|
||||
wStream staticS = { 0 };
|
||||
wStream* s = NULL;
|
||||
|
||||
#if 0
|
||||
BYTE payload[] = {
|
||||
|
@ -302,7 +323,7 @@ int TestNdrEarRead(int argc, char* argv[])
|
|||
size_t sizeofPayload4 = sizeof(payload4);
|
||||
#endif
|
||||
#if 1
|
||||
size_t sizeofPayload4;
|
||||
size_t sizeofPayload4 = 0;
|
||||
BYTE* payload4 = parseHexBlock("03 01 03 01 \
|
||||
04 00 02 00 38 9e ef 6b 0c 00 02 00 18 00 02 00 \
|
||||
20 00 02 00 00 00 00 00 24 00 02 00 2c 00 02 00 \
|
||||
|
@ -353,5 +374,8 @@ out:
|
|||
|
||||
int TestNdrEar(int argc, char* argv[])
|
||||
{
|
||||
const int rc = TestNdrEarWrite(argc, argv);
|
||||
if (rc)
|
||||
return rc;
|
||||
return TestNdrEarRead(argc, argv);
|
||||
}
|
||||
|
|
|
@ -171,8 +171,10 @@ UINT ecam_channel_write(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel,
|
|||
wStream* out, BOOL freeStream);
|
||||
|
||||
/* ecam device interface */
|
||||
void ecam_dev_destroy(CameraDevice* dev);
|
||||
|
||||
WINPR_ATTR_MALLOC(ecam_dev_destroy, 1)
|
||||
CameraDevice* ecam_dev_create(CameraPlugin* ecam, const char* deviceId, const char* deviceName);
|
||||
void ecam_dev_destroy(void* dev);
|
||||
|
||||
/* video encoding interface */
|
||||
BOOL ecam_encoder_context_init(CameraDeviceStream* stream);
|
||||
|
|
|
@ -316,6 +316,12 @@ static UINT ecam_on_new_channel_connection(IWTSListenerCallback* pListenerCallba
|
|||
return CHANNEL_RC_OK;
|
||||
}
|
||||
|
||||
static void ecam_dev_destroy_pv(void* obj)
|
||||
{
|
||||
CameraDevice* dev = obj;
|
||||
ecam_dev_destroy(dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* Function description
|
||||
*
|
||||
|
@ -349,7 +355,7 @@ static UINT ecam_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManage
|
|||
|
||||
wObject* obj = HashTable_ValueObject(ecam->devices);
|
||||
WINPR_ASSERT(obj);
|
||||
obj->fnObjectFree = ecam_dev_destroy;
|
||||
obj->fnObjectFree = ecam_dev_destroy_pv;
|
||||
|
||||
ecam->hlistener = (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
|
||||
|
||||
|
|
|
@ -796,9 +796,8 @@ CameraDevice* ecam_dev_create(CameraPlugin* ecam, const char* deviceId, const ch
|
|||
*
|
||||
* @return void
|
||||
*/
|
||||
void ecam_dev_destroy(void* obj)
|
||||
void ecam_dev_destroy(CameraDevice* dev)
|
||||
{
|
||||
CameraDevice* dev = (CameraDevice*)obj;
|
||||
if (!dev)
|
||||
return;
|
||||
|
||||
|
|
|
@ -142,10 +142,9 @@ static BOOL cam_v4l_format_supported(int fd, UINT32 format)
|
|||
*/
|
||||
static int cam_v4l_open_device(const char* deviceId, int flags)
|
||||
{
|
||||
UINT n;
|
||||
char device[20];
|
||||
char device[20] = { 0 };
|
||||
int fd = -1;
|
||||
struct v4l2_capability cap;
|
||||
struct v4l2_capability cap = { 0 };
|
||||
|
||||
if (!deviceId)
|
||||
return -1;
|
||||
|
@ -153,7 +152,7 @@ static int cam_v4l_open_device(const char* deviceId, int flags)
|
|||
if (0 == strncmp(deviceId, "/dev/video", 10))
|
||||
return open(deviceId, flags);
|
||||
|
||||
for (n = 0; n < 64; n++)
|
||||
for (UINT n = 0; n < 64; n++)
|
||||
{
|
||||
snprintf(device, sizeof(device), "/dev/video%d", n);
|
||||
if ((fd = open(device, flags)) == -1)
|
||||
|
@ -188,19 +187,19 @@ static INT16 cam_v4l_get_media_type_descriptions(ICamHal* hal, const char* devic
|
|||
CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes,
|
||||
size_t* nMediaTypes)
|
||||
{
|
||||
int fd;
|
||||
size_t maxMediaTypes = *nMediaTypes;
|
||||
size_t nTypes = 0;
|
||||
int formatIndex;
|
||||
BOOL formatFound = FALSE;
|
||||
|
||||
if ((fd = cam_v4l_open_device(deviceId, O_RDONLY)) == -1)
|
||||
int fd = cam_v4l_open_device(deviceId, O_RDONLY);
|
||||
if (fd == -1)
|
||||
{
|
||||
WLog_ERR(TAG, "Unable to open device %s", deviceId);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (formatIndex = 0; formatIndex < nSupportedFormats; formatIndex++)
|
||||
size_t formatIndex = 0;
|
||||
for (; formatIndex < nSupportedFormats; formatIndex++)
|
||||
{
|
||||
UINT32 pixelFormat = ecamToV4L2PixFormat(supportedFormats[formatIndex].inputFormat);
|
||||
WINPR_ASSERT(pixelFormat != 0);
|
||||
|
@ -268,7 +267,9 @@ error:
|
|||
|
||||
*nMediaTypes = nTypes;
|
||||
close(fd);
|
||||
return formatIndex;
|
||||
if (formatIndex > INT16_MAX)
|
||||
return -1;
|
||||
return (INT16)formatIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -279,16 +280,15 @@ error:
|
|||
static UINT cam_v4l_enumerate(ICamHal* ihal, ICamHalEnumCallback callback, CameraPlugin* ecam,
|
||||
GENERIC_CHANNEL_CALLBACK* hchannel)
|
||||
{
|
||||
UINT n, count = 0;
|
||||
char device[20];
|
||||
int fd = -1;
|
||||
struct v4l2_capability cap;
|
||||
char *deviceName, *deviceId;
|
||||
UINT count = 0;
|
||||
|
||||
for (n = 0; n < 64; n++)
|
||||
for (UINT n = 0; n < 64; n++)
|
||||
{
|
||||
char device[20] = { 0 };
|
||||
struct v4l2_capability cap = { 0 };
|
||||
snprintf(device, sizeof(device), "/dev/video%d", n);
|
||||
if ((fd = open(device, O_RDONLY)) == -1)
|
||||
int fd = open(device, O_RDONLY);
|
||||
if (fd == -1)
|
||||
continue;
|
||||
|
||||
/* query device capabilities and make sure this is a video capture device */
|
||||
|
@ -299,12 +299,10 @@ static UINT cam_v4l_enumerate(ICamHal* ihal, ICamHalEnumCallback callback, Camer
|
|||
}
|
||||
count++;
|
||||
|
||||
deviceName = (char*)cap.card;
|
||||
|
||||
const char* deviceName = (char*)cap.card;
|
||||
const char* deviceId = device;
|
||||
if (cap.bus_info[0] != 0) /* may not be available in all drivers */
|
||||
deviceId = (char*)cap.bus_info;
|
||||
else
|
||||
deviceId = device;
|
||||
|
||||
IFCALL(callback, ecam, hchannel, deviceId, deviceName);
|
||||
|
||||
|
@ -420,7 +418,7 @@ static UINT cam_v4l_stream_capture_thread(void* param)
|
|||
|
||||
do
|
||||
{
|
||||
int retVal;
|
||||
int retVal = 0;
|
||||
struct pollfd pfd = { 0 };
|
||||
|
||||
pfd.fd = fd;
|
||||
|
@ -540,8 +538,7 @@ UINT cam_v4l_stream_stop(CamV4lStream* stream)
|
|||
EnterCriticalSection(&stream->lock);
|
||||
|
||||
/* stop streaming */
|
||||
enum v4l2_buf_type type;
|
||||
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
if (ioctl(stream->fd, VIDIOC_STREAMOFF, &type) < 0)
|
||||
{
|
||||
WLog_ERR(TAG, "Failure in VIDIOC_STREAMOFF, errno %d", errno);
|
||||
|
@ -616,7 +613,8 @@ static UINT cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, int streamInd
|
|||
}
|
||||
|
||||
/* trying to set frame rate, if driver supports it */
|
||||
struct v4l2_streamparm sp1 = { 0 }, sp2 = { 0 };
|
||||
struct v4l2_streamparm sp1 = { 0 };
|
||||
struct v4l2_streamparm sp2 = { 0 };
|
||||
sp1.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
if (ioctl(stream->fd, VIDIOC_G_PARM, &sp1) < 0 ||
|
||||
!(sp1.parm.capture.capability & V4L2_CAP_TIMEPERFRAME))
|
||||
|
@ -648,8 +646,7 @@ static UINT cam_v4l_stream_start(ICamHal* ihal, CameraDevice* dev, int streamInd
|
|||
stream->streaming = TRUE;
|
||||
|
||||
/* start streaming */
|
||||
enum v4l2_buf_type type;
|
||||
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
if (ioctl(stream->fd, VIDIOC_STREAMON, &type) < 0)
|
||||
{
|
||||
WLog_ERR(TAG, "Failure in VIDIOC_STREAMON, errno %d", errno);
|
||||
|
|
|
@ -250,10 +250,9 @@ static UINT sshagent_on_new_channel_connection(IWTSListenerCallback* pListenerCa
|
|||
BOOL* pbAccept,
|
||||
IWTSVirtualChannelCallback** ppCallback)
|
||||
{
|
||||
SSHAGENT_CHANNEL_CALLBACK* callback;
|
||||
GENERIC_CHANNEL_CALLBACK* generic;
|
||||
SSHAGENT_LISTENER_CALLBACK* listener_callback = (SSHAGENT_LISTENER_CALLBACK*)pListenerCallback;
|
||||
callback = (SSHAGENT_CHANNEL_CALLBACK*)calloc(1, sizeof(SSHAGENT_CHANNEL_CALLBACK));
|
||||
SSHAGENT_CHANNEL_CALLBACK* callback =
|
||||
(SSHAGENT_CHANNEL_CALLBACK*)calloc(1, sizeof(SSHAGENT_CHANNEL_CALLBACK));
|
||||
|
||||
if (!callback)
|
||||
{
|
||||
|
@ -272,7 +271,8 @@ static UINT sshagent_on_new_channel_connection(IWTSListenerCallback* pListenerCa
|
|||
}
|
||||
|
||||
InitializeCriticalSection(&callback->lock);
|
||||
generic = &callback->generic;
|
||||
|
||||
GENERIC_CHANNEL_CALLBACK* generic = &callback->generic;
|
||||
generic->iface.OnDataReceived = sshagent_on_data_received;
|
||||
generic->iface.OnClose = sshagent_on_close;
|
||||
generic->plugin = listener_callback->plugin;
|
||||
|
@ -348,8 +348,7 @@ static UINT sshagent_plugin_terminated(IWTSPlugin* pPlugin)
|
|||
FREERDP_ENTRY_POINT(UINT VCAPITYPE sshagent_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
|
||||
{
|
||||
UINT status = CHANNEL_RC_OK;
|
||||
SSHAGENT_PLUGIN* sshagent;
|
||||
sshagent = (SSHAGENT_PLUGIN*)pEntryPoints->GetPlugin(pEntryPoints, "sshagent");
|
||||
SSHAGENT_PLUGIN* sshagent = (SSHAGENT_PLUGIN*)pEntryPoints->GetPlugin(pEntryPoints, "sshagent");
|
||||
|
||||
if (!sshagent)
|
||||
{
|
||||
|
|
|
@ -205,14 +205,13 @@ static void log_dec_info(const CStreamInfo* info, void (*log)(const char* fmt, .
|
|||
|
||||
static void log_enc_info(const AACENC_InfoStruct* info, fdk_log_fkt_t log)
|
||||
{
|
||||
size_t x;
|
||||
char confBuf[1024] = { 0 };
|
||||
|
||||
assert(info);
|
||||
assert(log);
|
||||
|
||||
strcat(confBuf, "{");
|
||||
for (x = 0; x < 64; x++)
|
||||
for (size_t x = 0; x < 64; x++)
|
||||
{
|
||||
char tmp[12] = { 0 };
|
||||
sprintf(tmp, "0x%02x", (int)info->confBuf[x]);
|
||||
|
@ -407,8 +406,6 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
"fdk_aac_dsp_impl_config: samplerate: %ld, channels: %ld, bytes_pers_second: %ld",
|
||||
samplerate, channels, bytes_per_second);
|
||||
|
||||
size_t x;
|
||||
AACENC_ERROR err;
|
||||
struct t_param_pair
|
||||
{
|
||||
AACENC_PARAM param;
|
||||
|
@ -422,7 +419,7 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
{ AACENC_BITRATE, bytes_per_second * 8 },
|
||||
{ AACENC_TRANSMUX, 0 },
|
||||
{ AACENC_AFTERBURNER, 1 } };
|
||||
HANDLE_AACENCODER self;
|
||||
HANDLE_AACENCODER self = NULL;
|
||||
if (encoder)
|
||||
self = (HANDLE_AACENCODER)handle;
|
||||
else
|
||||
|
@ -435,11 +432,11 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
}
|
||||
}
|
||||
|
||||
for (x = 0; x < sizeof(params) / sizeof(params[0]); x++)
|
||||
for (size_t x = 0; x < sizeof(params) / sizeof(params[0]); x++)
|
||||
{
|
||||
const struct t_param_pair* param = ¶ms[x];
|
||||
|
||||
err = aacEncoder_SetParam(self, param->param, param->value);
|
||||
AACENC_ERROR err = aacEncoder_SetParam(self, param->param, param->value);
|
||||
if (err != AACENC_OK)
|
||||
{
|
||||
log(WLOG_ERROR, "aacEncoder_SetParam(%s, %d) failed with %s",
|
||||
|
@ -448,7 +445,7 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
}
|
||||
}
|
||||
|
||||
err = aacEncEncode(self, NULL, NULL, NULL, NULL);
|
||||
AACENC_ERROR err = aacEncEncode(self, NULL, NULL, NULL, NULL);
|
||||
if (err != AACENC_OK)
|
||||
{
|
||||
log(WLOG_ERROR, "aacEncEncode failed with %s", enc_err_str(err));
|
||||
|
@ -477,7 +474,6 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
|
||||
*pbuffersize = info.frameLength * info.inputChannels * sizeof(INT_PCM);
|
||||
|
||||
AAC_DECODER_ERROR decerr;
|
||||
HANDLE_AACDECODER aacdec = (HANDLE_AACDECODER)handle;
|
||||
|
||||
UCHAR* asc[] = { info.confBuf };
|
||||
|
@ -485,7 +481,7 @@ int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsi
|
|||
|
||||
assert(handle);
|
||||
|
||||
decerr = aacDecoder_ConfigRaw(aacdec, asc, ascSize);
|
||||
AAC_DECODER_ERROR decerr = aacDecoder_ConfigRaw(aacdec, asc, ascSize);
|
||||
if (decerr != AAC_DEC_OK)
|
||||
{
|
||||
log(WLOG_ERROR, "aacDecoder_ConfigRaw failed with %s", dec_err_str(decerr));
|
||||
|
@ -501,15 +497,21 @@ ssize_t fdk_aac_dsp_impl_decode_fill(void* handle, const void* data, size_t size
|
|||
assert(log);
|
||||
|
||||
UINT leftBytes = size;
|
||||
AAC_DECODER_ERROR err;
|
||||
HANDLE_AACDECODER self = (HANDLE_AACDECODER)handle;
|
||||
UCHAR* pBuffer[] = { data };
|
||||
|
||||
union
|
||||
{
|
||||
const void* cpv;
|
||||
UCHAR* puc;
|
||||
} cnv;
|
||||
cnv.cpv = data;
|
||||
UCHAR* pBuffer[] = { cnv.puc };
|
||||
const UINT bufferSize[] = { size };
|
||||
|
||||
assert(handle);
|
||||
assert(data || (size == 0));
|
||||
|
||||
err = aacDecoder_Fill(self, pBuffer, bufferSize, &leftBytes);
|
||||
AAC_DECODER_ERROR err = aacDecoder_Fill(self, pBuffer, bufferSize, &leftBytes);
|
||||
if (err != AAC_DEC_OK)
|
||||
{
|
||||
log(WLOG_ERROR, "aacDecoder_Fill failed with %s", dec_err_str(err));
|
||||
|
@ -552,12 +554,16 @@ ssize_t fdk_aac_dsp_impl_stream_info(void* handle, int encoder, fdk_log_fkt_t lo
|
|||
ssize_t fdk_aac_dsp_impl_encode(void* handle, const void* data, size_t size, void* dst,
|
||||
size_t dstSize, fdk_log_fkt_t log)
|
||||
{
|
||||
AACENC_ERROR err;
|
||||
|
||||
INT inSizes[] = { size };
|
||||
INT inElSizes[] = { sizeof(INT_PCM) };
|
||||
INT inIdentifiers[] = { IN_AUDIO_DATA };
|
||||
void* inBuffers[] = { data };
|
||||
union
|
||||
{
|
||||
const void* cpv;
|
||||
void* pv;
|
||||
} cnv;
|
||||
cnv.cpv = data;
|
||||
void* inBuffers[] = { cnv.pv };
|
||||
|
||||
const AACENC_BufDesc inBufDesc = {
|
||||
.numBufs = 1,
|
||||
|
@ -587,7 +593,7 @@ ssize_t fdk_aac_dsp_impl_encode(void* handle, const void* data, size_t size, voi
|
|||
assert(handle);
|
||||
assert(log);
|
||||
|
||||
err = aacEncEncode(self, &inBufDesc, &outBufDesc, &inArgs, &outArgs);
|
||||
AACENC_ERROR err = aacEncEncode(self, &inBufDesc, &outBufDesc, &inArgs, &outArgs);
|
||||
if (err != AACENC_OK)
|
||||
{
|
||||
log(WLOG_ERROR, "aacEncEncode failed with %s", enc_err_str(err));
|
||||
|
|
|
@ -228,7 +228,7 @@ static int openh264_compress(H264_CONTEXT* WINPR_RESTRICT h264,
|
|||
return status;
|
||||
}
|
||||
|
||||
EUsageType usageType;
|
||||
EUsageType usageType = SCREEN_CONTENT_REAL_TIME;
|
||||
|
||||
switch (h264->UsageType)
|
||||
{
|
||||
|
@ -243,7 +243,6 @@ static int openh264_compress(H264_CONTEXT* WINPR_RESTRICT h264,
|
|||
break;
|
||||
case H264_SCREEN_CONTENT_REAL_TIME:
|
||||
default:
|
||||
usageType = SCREEN_CONTENT_REAL_TIME;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -1050,8 +1050,9 @@ progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressiv
|
|||
if (rc < 0)
|
||||
goto fail;
|
||||
|
||||
rc = prims->yCbCrToRGB_16s8u_P3AC4R((const INT16**)pSrcDst, 64 * 2, tile->data, tile->stride,
|
||||
progressive->format, &roi_64x64);
|
||||
const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
|
||||
rc = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride, progressive->format,
|
||||
&roi_64x64);
|
||||
fail:
|
||||
BufferPool_Return(progressive->bufferPool, pBuffer);
|
||||
return rc;
|
||||
|
@ -1494,8 +1495,9 @@ progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progress
|
|||
if (status < 0)
|
||||
goto fail;
|
||||
|
||||
status = prims->yCbCrToRGB_16s8u_P3AC4R((const INT16**)pSrcDst, 64 * 2, tile->data,
|
||||
tile->stride, progressive->format, &roi_64x64);
|
||||
const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
|
||||
status = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
|
||||
progressive->format, &roi_64x64);
|
||||
fail:
|
||||
BufferPool_Return(progressive->bufferPool, pBuffer);
|
||||
return status;
|
||||
|
|
|
@ -2096,42 +2096,36 @@ static BOOL rdp_write_bitmap_cache_v2_capability_set(wStream* s, const rdpSettin
|
|||
#ifdef WITH_DEBUG_CAPABILITIES
|
||||
static BOOL rdp_print_bitmap_cache_v2_capability_set(wStream* s)
|
||||
{
|
||||
UINT16 cacheFlags = 0;
|
||||
BYTE pad2 = 0;
|
||||
BYTE numCellCaches = 0;
|
||||
BITMAP_CACHE_V2_CELL_INFO bitmapCacheV2CellInfo[5];
|
||||
BITMAP_CACHE_V2_CELL_INFO bitmapCacheV2CellInfo[5] = { 0 };
|
||||
WLog_VRB(TAG, "BitmapCacheV2CapabilitySet (length %" PRIuz "):", Stream_GetRemainingLength(s));
|
||||
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 36))
|
||||
return FALSE;
|
||||
|
||||
Stream_Read_UINT16(s, cacheFlags); /* cacheFlags (2 bytes) */
|
||||
Stream_Read_UINT8(s, pad2); /* pad2 (1 byte) */
|
||||
Stream_Read_UINT8(s, numCellCaches); /* numCellCaches (1 byte) */
|
||||
rdp_read_bitmap_cache_cell_info(s,
|
||||
&bitmapCacheV2CellInfo[0]); /* bitmapCache0CellInfo (4 bytes) */
|
||||
rdp_read_bitmap_cache_cell_info(s,
|
||||
&bitmapCacheV2CellInfo[1]); /* bitmapCache1CellInfo (4 bytes) */
|
||||
rdp_read_bitmap_cache_cell_info(s,
|
||||
&bitmapCacheV2CellInfo[2]); /* bitmapCache2CellInfo (4 bytes) */
|
||||
rdp_read_bitmap_cache_cell_info(s,
|
||||
&bitmapCacheV2CellInfo[3]); /* bitmapCache3CellInfo (4 bytes) */
|
||||
rdp_read_bitmap_cache_cell_info(s,
|
||||
&bitmapCacheV2CellInfo[4]); /* bitmapCache4CellInfo (4 bytes) */
|
||||
Stream_Seek(s, 12); /* pad3 (12 bytes) */
|
||||
const UINT16 cacheFlags = Stream_Get_UINT16(s); /* cacheFlags (2 bytes) */
|
||||
const UINT8 pad2 = Stream_Get_UINT8(s); /* pad2 (1 byte) */
|
||||
const UINT8 numCellCaches = Stream_Get_UINT8(s); /* numCellCaches (1 byte) */
|
||||
|
||||
for (size_t x = 0; x < ARRAYSIZE(bitmapCacheV2CellInfo); x++)
|
||||
{
|
||||
if (!rdp_read_bitmap_cache_cell_info(
|
||||
s, &bitmapCacheV2CellInfo[x])) /* bitmapCache0CellInfo (4 bytes) */
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!Stream_SafeSeek(s, 12)) /* pad3 (12 bytes) */
|
||||
return FALSE;
|
||||
|
||||
WLog_VRB(TAG, "\tcacheFlags: 0x%04" PRIX16 "", cacheFlags);
|
||||
WLog_VRB(TAG, "\tpad2: 0x%02" PRIX8 "", pad2);
|
||||
WLog_VRB(TAG, "\tnumCellCaches: 0x%02" PRIX8 "", numCellCaches);
|
||||
WLog_VRB(TAG, "\tbitmapCache0CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
bitmapCacheV2CellInfo[0].numEntries, bitmapCacheV2CellInfo[0].persistent);
|
||||
WLog_VRB(TAG, "\tbitmapCache1CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
bitmapCacheV2CellInfo[1].numEntries, bitmapCacheV2CellInfo[1].persistent);
|
||||
WLog_VRB(TAG, "\tbitmapCache2CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
bitmapCacheV2CellInfo[2].numEntries, bitmapCacheV2CellInfo[2].persistent);
|
||||
WLog_VRB(TAG, "\tbitmapCache3CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
bitmapCacheV2CellInfo[3].numEntries, bitmapCacheV2CellInfo[3].persistent);
|
||||
WLog_VRB(TAG, "\tbitmapCache4CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
bitmapCacheV2CellInfo[4].numEntries, bitmapCacheV2CellInfo[4].persistent);
|
||||
for (size_t x = 0; x < ARRAYSIZE(bitmapCacheV2CellInfo); x++)
|
||||
{
|
||||
const BITMAP_CACHE_V2_CELL_INFO* info = &bitmapCacheV2CellInfo[x];
|
||||
WLog_VRB(TAG,
|
||||
"\tbitmapCache%" PRIuz "CellInfo: numEntries: %" PRIu32 " persistent: %" PRId32 "",
|
||||
x, info->numEntries, info->persistent);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -2850,8 +2850,9 @@ BOOL license_server_configure(rdpLicense* license)
|
|||
freerdp_settings_get_uint32(settings, FreeRDP_ServerLicenseProductVersion);
|
||||
const UINT32 issuerCount =
|
||||
freerdp_settings_get_uint32(settings, FreeRDP_ServerLicenseProductIssuersCount);
|
||||
const char** issuers =
|
||||
(const char**)freerdp_settings_get_pointer(settings, FreeRDP_ServerLicenseProductIssuers);
|
||||
|
||||
const void* ptr = freerdp_settings_get_pointer(settings, FreeRDP_ServerLicenseProductIssuers);
|
||||
const char** issuers = WINPR_REINTERPRET_CAST(ptr, const void*, const char**);
|
||||
|
||||
WINPR_ASSERT(CompanyName);
|
||||
WINPR_ASSERT(ProductName);
|
||||
|
|
|
@ -1426,13 +1426,13 @@ static BOOL nla_write_KERB_TICKET_LOGON(wStream* s, const KERB_TICKET_LOGON* tic
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL nla_get_KERB_TICKET_LOGON(rdpNla* nla, KERB_TICKET_LOGON* logonTicket)
|
||||
static BOOL nla_get_KERB_TICKET_LOGON(rdpNla* nla, KERB_TICKET_LOGON* logonTicket)
|
||||
{
|
||||
WINPR_ASSERT(nla);
|
||||
WINPR_ASSERT(logonTicket);
|
||||
|
||||
SecurityFunctionTable* table;
|
||||
CtxtHandle context;
|
||||
SecurityFunctionTable* table = NULL;
|
||||
CtxtHandle context = { 0 };
|
||||
credssp_auth_tableAndContext(nla->auth, &table, &context);
|
||||
return table->QueryContextAttributes(&context, SECPKG_CRED_ATTR_TICKET_LOGON, logonTicket) ==
|
||||
SEC_E_OK;
|
||||
|
@ -2223,8 +2223,8 @@ SECURITY_STATUS nla_QueryContextAttributes(rdpNla* nla, DWORD ulAttr, PVOID pBuf
|
|||
{
|
||||
WINPR_ASSERT(nla);
|
||||
|
||||
SecurityFunctionTable* table;
|
||||
CtxtHandle context;
|
||||
SecurityFunctionTable* table = NULL;
|
||||
CtxtHandle context = { 0 };
|
||||
credssp_auth_tableAndContext(nla->auth, &table, &context);
|
||||
|
||||
return table->QueryContextAttributes(&context, ulAttr, pBuffer);
|
||||
|
|
|
@ -605,12 +605,13 @@ BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId)
|
|||
* when the user logs off like they should. Map DisconnectProviderUltimatum
|
||||
* to a ERRINFO_LOGOFF_BY_USER when the errinfo code is ERRINFO_SUCCESS.
|
||||
*/
|
||||
UINT32 errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
|
||||
if (reason == Disconnect_Ultimatum_provider_initiated)
|
||||
rdp_set_error_info(rdp, ERRINFO_RPC_INITIATED_DISCONNECT);
|
||||
errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
|
||||
else if (reason == Disconnect_Ultimatum_user_requested)
|
||||
rdp_set_error_info(rdp, ERRINFO_LOGOFF_BY_USER);
|
||||
else
|
||||
rdp_set_error_info(rdp, ERRINFO_RPC_INITIATED_DISCONNECT);
|
||||
errorInfo = ERRINFO_LOGOFF_BY_USER;
|
||||
|
||||
rdp_set_error_info(rdp, errorInfo);
|
||||
}
|
||||
|
||||
WLog_Print(rdp->log, WLOG_DEBUG, "DisconnectProviderUltimatum: reason: %d", reason);
|
||||
|
|
|
@ -315,7 +315,7 @@ static long bio_rdp_tls_ctrl(BIO* bio, int cmd, long num, void* ptr)
|
|||
*
|
||||
* This, of course, is something compilers warn about. So silence it by casting */
|
||||
{
|
||||
void* vptr = (void*)SSL_get_info_callback(tls->ssl);
|
||||
void* vptr = WINPR_FUNC_PTR_CAST(SSL_get_info_callback(tls->ssl), void*);
|
||||
*((void**)ptr) = vptr;
|
||||
status = 1;
|
||||
}
|
||||
|
|
|
@ -202,7 +202,8 @@ error:
|
|||
{
|
||||
int saved_errno = errno;
|
||||
if (terminal_needs_reset)
|
||||
tcsetattr(terminal_fildes, TCSAFLUSH, &orig_flags);
|
||||
(void)tcsetattr(terminal_fildes, TCSAFLUSH, &orig_flags);
|
||||
|
||||
if (terminal_fildes != STDIN_FILENO)
|
||||
{
|
||||
if (fp)
|
||||
|
|
|
@ -921,15 +921,19 @@ extern "C"
|
|||
WINPR_ASSERT(_s);
|
||||
WINPR_ASSERT(_s->pointer);
|
||||
WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 8);
|
||||
*_s->pointer++ = (_v)&0xFF;
|
||||
*_s->pointer++ = (_v >> 8) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 16) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 24) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 32) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 40) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 48) & 0xFF;
|
||||
*_s->pointer++ = (_v >> 56) & 0xFF;
|
||||
Stream_Write_UINT32(_s, ((_v)&0xFFFFFFFFUL));
|
||||
Stream_Write_UINT32(_s, ((_v) >> 16 & 0xFFFFFFFFUL));
|
||||
}
|
||||
|
||||
static INLINE void Stream_Write_UINT64_BE(wStream* _s, UINT64 _v)
|
||||
{
|
||||
WINPR_ASSERT(_s);
|
||||
WINPR_ASSERT(_s->pointer);
|
||||
WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 8);
|
||||
Stream_Write_UINT32_BE(_s, ((_v) >> 16 & 0xFFFFFFFFUL));
|
||||
Stream_Write_UINT32_BE(_s, ((_v)&0xFFFFFFFFUL));
|
||||
}
|
||||
|
||||
static INLINE void Stream_Write(wStream* _s, const void* _b, size_t _n)
|
||||
{
|
||||
if (_n > 0)
|
||||
|
|
|
@ -138,6 +138,24 @@ WINPR_API const char* winpr_get_build_config(void);
|
|||
#define WINPR_UNUSED(x) (void)(x)
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
/**
|
||||
* @brief A macro to do dirty casts. Do not use without a good justification!
|
||||
* @param ptr The pointer to cast
|
||||
* @param dstType The data type to cast to
|
||||
* @return The casted pointer
|
||||
* @since version 3.9.0
|
||||
*/
|
||||
#define WINPR_REINTERPRET_CAST(ptr, srcType, dstType) \
|
||||
({ \
|
||||
union \
|
||||
{ \
|
||||
srcType src; \
|
||||
dstType dst; \
|
||||
} cnv; \
|
||||
cnv.src = ptr; \
|
||||
cnv.dst; \
|
||||
})
|
||||
|
||||
/**
|
||||
* @brief A macro to do dirty casts. Do not use without a good justification!
|
||||
* @param ptr The pointer to cast
|
||||
|
@ -174,6 +192,7 @@ WINPR_API const char* winpr_get_build_config(void);
|
|||
cnv.dst; \
|
||||
})
|
||||
#else
|
||||
#define WINPR_REINTERPRET_CAST(ptr, srcType, dstType) (dstType) ptr
|
||||
#define WINPR_CAST_CONST_PTR_AWAY(ptr, dstType) (dstType) ptr
|
||||
#define WINPR_FUNC_PTR_CAST(ptr, dstType) (dstType)(uintptr_t) ptr
|
||||
#endif
|
||||
|
|
|
@ -241,16 +241,19 @@ static BOOL isValidIP(const char* ipAddress)
|
|||
static int build_krbtgt(krb5_context ctx, krb5_data* realm, krb5_principal* ptarget)
|
||||
{
|
||||
/* "krbtgt/" + realm + "@" + realm */
|
||||
size_t len = 7ULL + realm->length + 1 + realm->length + 1;
|
||||
char* name = malloc(len);
|
||||
if (!name)
|
||||
return KRB5_CC_NOMEM;
|
||||
size_t len = 0;
|
||||
char* name = NULL;
|
||||
krb5_error_code rv = KRB5_CC_NOMEM;
|
||||
|
||||
(void)snprintf(name, len, "krbtgt/%s@%s", realm->data, realm->data);
|
||||
krb5_principal target;
|
||||
int rv = krb5_parse_name(ctx, name, &target);
|
||||
free(name);
|
||||
(void)winpr_asprintf(&name, &len, "krbtgt/%s@%s", realm->data, realm->data);
|
||||
if (!name || (len == 0))
|
||||
goto fail;
|
||||
|
||||
krb5_principal target = { 0 };
|
||||
rv = krb5_parse_name(ctx, name, &target);
|
||||
*ptarget = target;
|
||||
fail:
|
||||
free(name);
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
@ -899,7 +902,8 @@ static SECURITY_STATUS SEC_ENTRY kerberos_InitializeSecurityContextA(
|
|||
|
||||
isNewContext = TRUE;
|
||||
|
||||
context->targetHost = _strdup(host);
|
||||
if (host)
|
||||
context->targetHost = _strdup(host);
|
||||
if (!context->targetHost)
|
||||
{
|
||||
status = SEC_E_INSUFFICIENT_MEMORY;
|
||||
|
|
|
@ -234,6 +234,7 @@ static BOOL CALLBACK load_timezones(PINIT_ONCE once, PVOID param, PVOID* pvconte
|
|||
|
||||
#if defined(WITH_TIMEZONE_FROM_FILE) && defined(WITH_WINPR_JSON)
|
||||
{
|
||||
WINPR_JSON* json = NULL;
|
||||
char* filename = GetCombinedPath(WINPR_RESOURCE_ROOT, "TimeZoneNameMap.json");
|
||||
if (!filename)
|
||||
{
|
||||
|
@ -241,7 +242,7 @@ static BOOL CALLBACK load_timezones(PINIT_ONCE once, PVOID param, PVOID* pvconte
|
|||
goto end;
|
||||
}
|
||||
|
||||
WINPR_JSON* json = load_timezones_from_file(filename);
|
||||
json = load_timezones_from_file(filename);
|
||||
if (!json)
|
||||
goto end;
|
||||
|
||||
|
|
|
@ -121,7 +121,8 @@ static INLINE size_t HashTable_CalculateIdealNumOfBuckets(wHashTable* table)
|
|||
{
|
||||
WINPR_ASSERT(table);
|
||||
|
||||
const float tmp = (table->numOfElements / table->idealRatio);
|
||||
const float numOfElements = (float)table->numOfElements;
|
||||
const float tmp = (numOfElements / table->idealRatio);
|
||||
size_t idealNumOfBuckets = (size_t)tmp;
|
||||
|
||||
if (idealNumOfBuckets < 5)
|
||||
|
|
|
@ -5,12 +5,11 @@
|
|||
|
||||
int TestWtsApiExtraDisconnectSession(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
HANDLE hServer;
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
|
||||
bSuccess = WTSDisconnectSession(hServer, WTS_CURRENT_SESSION, FALSE);
|
||||
HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
BOOL bSuccess = WTSDisconnectSession(hServer, WTS_CURRENT_SESSION, FALSE);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
|
|
@ -5,16 +5,10 @@
|
|||
|
||||
int TestWtsApiExtraDynamicVirtualChannel(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
ULONG length;
|
||||
ULONG bytesRead;
|
||||
ULONG bytesWritten;
|
||||
BYTE buffer[1024];
|
||||
HANDLE hVirtualChannel;
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
length = sizeof(buffer);
|
||||
|
||||
hVirtualChannel =
|
||||
HANDLE hVirtualChannel =
|
||||
WTSVirtualChannelOpenEx(WTS_CURRENT_SESSION, "ECHO", WTS_CHANNEL_OPTION_DYNAMIC);
|
||||
|
||||
if (hVirtualChannel == INVALID_HANDLE_VALUE)
|
||||
|
@ -23,8 +17,10 @@ int TestWtsApiExtraDynamicVirtualChannel(int argc, char* argv[])
|
|||
return -1;
|
||||
}
|
||||
printf("WTSVirtualChannelOpen opend");
|
||||
bytesWritten = 0;
|
||||
bSuccess = WTSVirtualChannelWrite(hVirtualChannel, (PCHAR)buffer, length, &bytesWritten);
|
||||
ULONG bytesWritten = 0;
|
||||
char buffer[1024] = { 0 };
|
||||
size_t length = sizeof(buffer);
|
||||
BOOL bSuccess = WTSVirtualChannelWrite(hVirtualChannel, buffer, length, &bytesWritten);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
@ -33,7 +29,7 @@ int TestWtsApiExtraDynamicVirtualChannel(int argc, char* argv[])
|
|||
}
|
||||
printf("WTSVirtualChannelWrite written");
|
||||
|
||||
bytesRead = 0;
|
||||
ULONG bytesRead = 0;
|
||||
bSuccess = WTSVirtualChannelRead(hVirtualChannel, 5000, (PCHAR)buffer, length, &bytesRead);
|
||||
|
||||
if (!bSuccess)
|
||||
|
|
|
@ -5,12 +5,12 @@
|
|||
|
||||
int TestWtsApiExtraLogoffSession(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
HANDLE hServer;
|
||||
|
||||
hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
bSuccess = WTSLogoffSession(hServer, WTS_CURRENT_SESSION, FALSE);
|
||||
HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
BOOL bSuccess = WTSLogoffSession(hServer, WTS_CURRENT_SESSION, FALSE);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
|
|
@ -9,14 +9,13 @@
|
|||
|
||||
int TestWtsApiExtraSendMessage(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
HANDLE hServer;
|
||||
DWORD result;
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
|
||||
bSuccess = WTSSendMessageA(hServer, WTS_CURRENT_SESSION, TITLE, strlen(TITLE) + 1, MESSAGE,
|
||||
strlen(MESSAGE) + 1, MB_CANCELTRYCONTINUE, 3, &result, TRUE);
|
||||
HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
|
||||
DWORD result = 0;
|
||||
BOOL bSuccess = WTSSendMessageA(hServer, WTS_CURRENT_SESSION, TITLE, strlen(TITLE) + 1, MESSAGE,
|
||||
strlen(MESSAGE) + 1, MB_CANCELTRYCONTINUE, 3, &result, TRUE);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
|
|
@ -7,12 +7,14 @@
|
|||
|
||||
int TestWtsApiExtraStartRemoteSessionEx(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
ULONG logonId = 0;
|
||||
char logonIdStr[10];
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
bSuccess = GetEnvironmentVariableA("TEST_SESSION_LOGON_ID", logonIdStr, 10);
|
||||
if (bSuccess)
|
||||
ULONG logonId = 0;
|
||||
char logonIdStr[10] = { 0 };
|
||||
|
||||
DWORD bSuccess = GetEnvironmentVariableA("TEST_SESSION_LOGON_ID", logonIdStr, 10);
|
||||
if (bSuccess > 0)
|
||||
{
|
||||
sscanf(logonIdStr, "%u\n", &logonId);
|
||||
}
|
||||
|
|
|
@ -5,16 +5,14 @@
|
|||
|
||||
int TestWtsApiExtraVirtualChannel(int argc, char* argv[])
|
||||
{
|
||||
BOOL bSuccess;
|
||||
ULONG length;
|
||||
ULONG bytesRead;
|
||||
ULONG bytesWritten;
|
||||
BYTE buffer[1024];
|
||||
HANDLE hVirtualChannel;
|
||||
|
||||
length = sizeof(buffer);
|
||||
WINPR_UNUSED(argc);
|
||||
WINPR_UNUSED(argv);
|
||||
|
||||
hVirtualChannel =
|
||||
char buffer[1024] = { 0 };
|
||||
const size_t length = sizeof(buffer);
|
||||
|
||||
HANDLE hVirtualChannel =
|
||||
WTSVirtualChannelOpen(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, "sample");
|
||||
|
||||
if (hVirtualChannel == INVALID_HANDLE_VALUE)
|
||||
|
@ -23,8 +21,8 @@ int TestWtsApiExtraVirtualChannel(int argc, char* argv[])
|
|||
return -1;
|
||||
}
|
||||
printf("WTSVirtualChannelOpen opend");
|
||||
bytesWritten = 0;
|
||||
bSuccess = WTSVirtualChannelWrite(hVirtualChannel, (PCHAR)buffer, length, &bytesWritten);
|
||||
ULONG bytesWritten = 0;
|
||||
BOOL bSuccess = WTSVirtualChannelWrite(hVirtualChannel, buffer, length, &bytesWritten);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
@ -33,8 +31,8 @@ int TestWtsApiExtraVirtualChannel(int argc, char* argv[])
|
|||
}
|
||||
printf("WTSVirtualChannelWrite written");
|
||||
|
||||
bytesRead = 0;
|
||||
bSuccess = WTSVirtualChannelRead(hVirtualChannel, 5000, (PCHAR)buffer, length, &bytesRead);
|
||||
ULONG bytesRead = 0;
|
||||
bSuccess = WTSVirtualChannelRead(hVirtualChannel, 5000, buffer, length, &bytesRead);
|
||||
|
||||
if (!bSuccess)
|
||||
{
|
||||
|
|
Loading…
Reference in New Issue