DWORD
DNSUpdateSendUpdateRequest2(
HANDLE hDNSServer,
PDNS_UPDATE_REQUEST pDNSRequest
)
{
DWORD dwError = 0;
DWORD dwBytesSent = 0;
HANDLE hSendBuffer = (HANDLE)NULL;
dwError = DNSUpdateBuildRequestMessage(
pDNSRequest,
&hSendBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSSendBufferContext(
hDNSServer,
hSendBuffer,
&dwBytesSent);
BAIL_ON_LWDNS_ERROR(dwError);
cleanup:
if (hSendBuffer)
{
DNSFreeSendBufferContext(hSendBuffer);
}
return dwError;
error:
goto cleanup;
}
DWORD
DNSUpdateBuildRequestMessage(
PDNS_UPDATE_REQUEST pDNSRequest,
HANDLE * phSendBuffer
)
{
DWORD dwError = 0;
CHAR header[12];
WORD wnIdentification = 0;
WORD wnParameter = 0;
WORD wnZones = 0;
WORD wnPRs = 0;
WORD wnUpdates = 0;
WORD wnAdditionals = 0;
DWORD dwRead = 0;
HANDLE hSendBuffer = (HANDLE)NULL;
dwError = DNSCreateSendBuffer(&hSendBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
wnIdentification = htons(pDNSRequest->wIdentification);
memcpy(header, (char *)&wnIdentification, 2);
wnParameter = htons(pDNSRequest->wParameter);
memcpy(&header[2], (char *)&wnParameter, sizeof(wnParameter));
wnZones = htons(pDNSRequest->wZones);
memcpy(&header[4], (char *)&wnZones, sizeof(wnZones));
wnPRs = htons(pDNSRequest->wPRs);
memcpy(&header[6], (char *)&wnPRs, sizeof(wnPRs));
wnUpdates = htons(pDNSRequest->wUpdates);
memcpy(&header[8], (char *)&wnUpdates, sizeof(wnUpdates));
wnAdditionals = htons(pDNSRequest->wAdditionals);
memcpy(&header[10], (char *)&wnAdditionals, sizeof(wnAdditionals));
dwError = DNSMarshallBuffer(
hSendBuffer,
(PBYTE)header,
sizeof(header),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
if (pDNSRequest->wZones) {
dwError = DNSUpdateMarshallZoneSection(
hSendBuffer,
pDNSRequest->ppZoneRRSet,
pDNSRequest->wZones);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (pDNSRequest->wPRs) {
dwError = DNSUpdateMarshallPRSection(
hSendBuffer,
pDNSRequest->ppPRRRSet,
pDNSRequest->wPRs);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (pDNSRequest->wUpdates) {
dwError = DNSUpdateMarshallUpdateSection(
hSendBuffer,
pDNSRequest->ppUpdateRRSet,
pDNSRequest->wUpdates);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (pDNSRequest->wAdditionals) {
dwError = DNSUpdateMarshallAdditionalSection(
hSendBuffer,
pDNSRequest->ppAdditionalRRSet,
pDNSRequest->wAdditionals);
BAIL_ON_LWDNS_ERROR(dwError);
}
DNSDumpSendBufferContext(hSendBuffer);
*phSendBuffer = hSendBuffer;
cleanup:
return dwError;
error:
if(hSendBuffer) {
DNSFreeSendBufferContext(hSendBuffer);
}
*phSendBuffer = (HANDLE)NULL;
goto cleanup;
}
DWORD
DNSUpdateGenerateSignature(
PCtxtHandle pGSSContext,
PDNS_UPDATE_REQUEST pDNSUpdateRequest,
PCSTR pszKeyName
)
{
DWORD dwError = 0;
DWORD dwMinorStatus = 0;
HANDLE hSendBuffer = (HANDLE)NULL;
PBYTE pMessageBuffer = NULL;
DWORD dwMessageSize = 0;
DWORD dwTimeSigned = 0;
WORD wFudge = 0;
gss_buffer_desc MsgDesc = {0};
gss_buffer_desc MicDesc = {0};
PDNS_RR_RECORD pDNSTSIGRecord = NULL;
dwError = DNSBuildMessageBuffer(
pDNSUpdateRequest,
pszKeyName,
&dwTimeSigned,
&wFudge,
&pMessageBuffer,
&dwMessageSize);
BAIL_ON_LWDNS_ERROR(dwError);
MsgDesc.value = pMessageBuffer;
MsgDesc.length = dwMessageSize;
MicDesc.value = NULL;
MicDesc.length = 0;
dwError = gss_get_mic(
(OM_uint32 *)&dwMinorStatus,
*pGSSContext,
0,
&MsgDesc,
&MicDesc);
lwdns_display_status("gss_init_context", dwError, dwMinorStatus);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSCreateTSIGRecord(
pszKeyName,
dwTimeSigned,
wFudge,
pDNSUpdateRequest->wIdentification,
MicDesc.value,
MicDesc.length,
&pDNSTSIGRecord);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUpdateAddAdditionalSection(
pDNSUpdateRequest,
pDNSTSIGRecord);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSTSIGRecord = NULL;
cleanup:
gss_release_buffer(&dwMinorStatus, &MicDesc);
if (pDNSTSIGRecord)
{
DNSFreeRecord(pDNSTSIGRecord);
}
if (hSendBuffer) {
DNSFreeSendBufferContext(hSendBuffer);
}
if (pMessageBuffer) {
DNSFreeMemory(pMessageBuffer);
}
return(dwError);
error:
goto cleanup;
}
DWORD
DNSBuildMessageBuffer(
PDNS_UPDATE_REQUEST pDNSUpdateRequest,
PCSTR pszKeyName,
DWORD * pdwTimeSigned,
WORD * pwFudge,
PBYTE * ppMessageBuffer,
PDWORD pdwMessageSize
)
{
DWORD dwError = 0;
PBYTE pSrcBuffer = NULL;
DWORD dwReqMsgSize = 0;
DWORD dwAlgorithmLen = 0;
DWORD dwNameLen = 0;
PBYTE pMessageBuffer = NULL;
DWORD dwMessageSize = 0;
PBYTE pOffset = NULL;
WORD wnError, wError = 0;
WORD wnFudge = 0;
WORD wFudge = DNS_ONE_HOUR_IN_SECS;
WORD wnOtherLen = 0, wOtherLen = 0;
DWORD dwBytesCopied = 0;
WORD wnClass = 0, wClass = DNS_CLASS_ANY;
DWORD dwnTTL = 0, dwTTL = 0;
DWORD dwnTimeSigned, dwTimeSigned = 0;
HANDLE hSendBuffer = (HANDLE)NULL;
PDNS_DOMAIN_NAME pDomainName = NULL;
PDNS_DOMAIN_NAME pAlgorithmName = NULL;
//PBYTE pOtherLen = NULL;
WORD wTimePrefix = 0;
WORD wnTimePrefix = 0;
dwError = DNSDomainNameFromString(pszKeyName, &pDomainName);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSGetDomainNameLength(pDomainName, &dwNameLen);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSDomainNameFromString(DNS_GSS_ALGORITHM, &pAlgorithmName);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSGetDomainNameLength(pAlgorithmName, &dwAlgorithmLen);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUpdateBuildRequestMessage(
pDNSUpdateRequest,
&hSendBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
dwReqMsgSize = DNSGetSendBufferContextSize(hSendBuffer);
dwMessageSize += dwReqMsgSize;
dwMessageSize += dwNameLen;
dwMessageSize += sizeof(WORD); //CLASS
dwMessageSize += sizeof(DWORD); //TTL
dwMessageSize += dwAlgorithmLen;
dwMessageSize += (sizeof(WORD) + sizeof(DWORD)); //Time Signed
dwMessageSize += sizeof(WORD); //Fudge
dwMessageSize += sizeof(WORD); //wError
dwMessageSize += sizeof(WORD); //Other Len
dwMessageSize += wOtherLen;
dwError = DNSAllocateMemory(
dwMessageSize,
(PVOID *)&pMessageBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
pOffset = pMessageBuffer;
pSrcBuffer = DNSGetSendBufferContextBuffer(hSendBuffer);
memcpy(pOffset, pSrcBuffer, dwReqMsgSize);
pOffset += dwReqMsgSize;
dwError = DNSCopyDomainName(pOffset, pDomainName, &dwBytesCopied);
BAIL_ON_LWDNS_ERROR(dwError);
pOffset += dwBytesCopied;
wnClass = htons(wClass);
memcpy(pOffset, &wnClass, sizeof(WORD));
pOffset += sizeof(WORD);
dwnTTL = htonl(dwTTL);
memcpy(pOffset, &dwnTTL, sizeof(DWORD));
pOffset += sizeof(DWORD);
dwError = DNSCopyDomainName(pOffset, pAlgorithmName, &dwBytesCopied);
BAIL_ON_LWDNS_ERROR(dwError);
pOffset += dwBytesCopied;
wnTimePrefix = htons(wTimePrefix);
memcpy(pOffset, &wnTimePrefix, sizeof(WORD));
pOffset += sizeof(WORD);
time((time_t*)&dwTimeSigned);
dwnTimeSigned = htonl(dwTimeSigned);
memcpy(pOffset, &dwnTimeSigned, sizeof(DWORD));
pOffset += sizeof(DWORD);
wnFudge = htons(wFudge);
memcpy(pOffset, &wnFudge, sizeof(WORD));
pOffset += sizeof(WORD);
wnError = htons(wError);
memcpy(pOffset, &wnError, sizeof(WORD));
pOffset += sizeof(WORD);
wnOtherLen = htons(wOtherLen);
memcpy(pOffset, &wnOtherLen, sizeof(WORD));
pOffset += sizeof(WORD);
*ppMessageBuffer = pMessageBuffer;
*pdwMessageSize = dwMessageSize;
*pdwTimeSigned = dwTimeSigned;
*pwFudge = wFudge;
cleanup:
if (pAlgorithmName)
{
DNSFreeDomainName(pAlgorithmName);
}
if (pDomainName)
{
DNSFreeDomainName(pDomainName);
}
if (hSendBuffer != (HANDLE)NULL)
{
DNSFreeSendBufferContext(hSendBuffer);
}
return(dwError);
error:
if (pMessageBuffer) {
DNSFreeMemory(pMessageBuffer);
}
*ppMessageBuffer = NULL;
*pdwMessageSize = 0;
*pdwTimeSigned = dwTimeSigned;
*pwFudge = wFudge;
goto cleanup;
}
