Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-20 12:29:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

Convert the dnsapi stuff to a consistent 4 spaces indentation

Browse source 
svn path=/trunk/; revision=34298
This commit is contained in:
Colin Finck 2008-07-04 22:41:28 +00:00
parent 458e927317
commit 138bd07f65
7 changed files with 1115 additions and 850 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
reactos/dll/win32/dnsapi/dnsapi/adns.c
View file

@ -13,14 +13,17 @@
#define NDEBUG
#include <debug.h>
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS( int Status ) {
switch( Status ) {
case adns_s_ok:
return ERROR_SUCCESS;
case adns_s_nomemory:
case adns_s_systemfail:
default: /* There really aren't any general errors in the dns part. */
return ERROR_OUTOFMEMORY;
}
}
DNS_STATUS
DnsIntTranslateAdnsToDNS_STATUS(int Status)
{
switch(Status)
{
case adns_s_ok:
return ERROR_SUCCESS;
case adns_s_nomemory:
case adns_s_systemfail:
default: /* There really aren't any general errors in the dns part. */
return ERROR_OUTOFMEMORY;
}
}

149
reactos/dll/win32/dnsapi/dnsapi/context.c
View file

@ -30,96 +30,95 @@
* TODO: Which ones area allowed?
*/
extern DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8
( DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle );
extern DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8(DWORD CredentialsFlags, PVOID Credentials, HANDLE *ContextHandle);
DNS_STATUS WINAPI DnsAcquireContextHandle_W
( DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle ) {
if( CredentialsFlags ) {
PWINDNS_CONTEXT Context;
int adns_status;
DNS_STATUS WINAPI
DnsAcquireContextHandle_W(DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle)
{
if(CredentialsFlags)
{
PWINDNS_CONTEXT Context;
int adns_status;
/* For now, don't worry about the user's identity. */
Context = (PWINDNS_CONTEXT)RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof( WINDNS_CONTEXT ) );
/* For now, don't worry about the user's identity. */
Context = (PWINDNS_CONTEXT)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WINDNS_CONTEXT));
if(!Context){
*ContextHandle = 0;
return ERROR_OUTOFMEMORY;
if(!Context)
{
*ContextHandle = 0;
return ERROR_OUTOFMEMORY;
}
/* The real work here is to create an adns_state that will help us
* do what we want to later. */
adns_status = adns_init(&Context->State, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn, 0);
if(adns_status != adns_s_ok)
{
*ContextHandle = 0;
RtlFreeHeap(RtlGetProcessHeap(), 0, Context);
return DnsIntTranslateAdnsToDNS_STATUS(adns_status);
}
else
{
*ContextHandle = (HANDLE)Context;
return ERROR_SUCCESS;
}
}
/* The real work here is to create an adns_state that will help us
* do what we want to later. */
adns_status = adns_init( &Context->State,
adns_if_noenv |
adns_if_noerrprint |
adns_if_noserverwarn,
0 );
if( adns_status != adns_s_ok ) {
*ContextHandle = 0;
RtlFreeHeap( RtlGetProcessHeap(), 0, Context );
return DnsIntTranslateAdnsToDNS_STATUS( adns_status );
} else {
*ContextHandle = (HANDLE)Context;
return ERROR_SUCCESS;
else
{
return DnsAcquireContextHandle_UTF8(CredentialsFlags, Credentials, ContextHandle);
}
} else {
return DnsAcquireContextHandle_UTF8( CredentialsFlags,
Credentials,
ContextHandle );
}
}
DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8
( DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle ) {
if( CredentialsFlags ) {
return DnsAcquireContextHandle_W( CredentialsFlags,
Credentials,
ContextHandle );
} else {
/* Convert to unicode, then call the _W version
* For now, there is no conversion */
DNS_STATUS Status;
DNS_STATUS WINAPI
DnsAcquireContextHandle_UTF8(DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle)
{
if( CredentialsFlags )
{
return DnsAcquireContextHandle_W(CredentialsFlags, Credentials, ContextHandle);
}
else
{
/* Convert to unicode, then call the _W version
* For now, there is no conversion */
DNS_STATUS Status;
Status = DnsAcquireContextHandle_W( TRUE,
Credentials, /* XXX arty */
ContextHandle );
Status = DnsAcquireContextHandle_W(TRUE, Credentials, /* XXX arty */ ContextHandle);
/* Free the unicode credentials when they exist. */
/* Free the unicode credentials when they exist. */
return Status;
}
return Status;
}
}
DNS_STATUS WINAPI DnsAcquireContextHandle_A
( DWORD CredentialFlags,
PVOID Credentials,
HANDLE *ContextHandle ) {
if( CredentialFlags ) {
return DnsAcquireContextHandle_W( CredentialFlags,
Credentials,
ContextHandle );
} else {
return DnsAcquireContextHandle_UTF8( CredentialFlags,
Credentials,
ContextHandle );
}
DNS_STATUS WINAPI
DnsAcquireContextHandle_A(DWORD CredentialFlags,
PVOID Credentials,
HANDLE *ContextHandle)
{
if(CredentialFlags)
{
return DnsAcquireContextHandle_W(CredentialFlags, Credentials, ContextHandle);
}
else
{
return DnsAcquireContextHandle_UTF8(CredentialFlags, Credentials, ContextHandle);
}
}
/* DnsReleaseContextHandle *************
* Release a context handle, freeing all resources.
*/
void WINAPI
DnsReleaseContextHandle(HANDLE ContextHandle)
{
PWINDNS_CONTEXT Context = (PWINDNS_CONTEXT)ContextHandle;
void WINAPI DnsReleaseContextHandle
( HANDLE ContextHandle ) {
PWINDNS_CONTEXT Context = (PWINDNS_CONTEXT)ContextHandle;
adns_finish( Context->State );
RtlFreeHeap( RtlGetProcessHeap(), 0, Context );
adns_finish(Context->State);
RtlFreeHeap(RtlGetProcessHeap(), 0, Context);
}

37
reactos/dll/win32/dnsapi/dnsapi/free.c
View file

@ -13,24 +13,29 @@
#define NDEBUG
#include <debug.h>
VOID WINAPI DnsFree
( PVOID Data, DNS_FREE_TYPE FreeType ) {
switch( FreeType ) {
case DnsFreeFlat:
RtlFreeHeap( RtlGetProcessHeap(), 0, Data );
break;
VOID WINAPI
DnsFree(PVOID Data,
DNS_FREE_TYPE FreeType)
{
switch(FreeType)
{
case DnsFreeFlat:
RtlFreeHeap( RtlGetProcessHeap(), 0, Data );
break;
case DnsFreeRecordList:
DnsIntFreeRecordList( (PDNS_RECORD)Data );
break;
case DnsFreeRecordList:
DnsIntFreeRecordList( (PDNS_RECORD)Data );
break;
case DnsFreeParsedMessageFields:
/* assert( FALSE ); XXX arty not yet implemented. */
break;
}
case DnsFreeParsedMessageFields:
/* assert( FALSE ); XXX arty not yet implemented. */
break;
}
}
VOID WINAPI DnsRecordListFree
( PDNS_RECORD Data, DNS_FREE_TYPE FreeType ) {
DnsFree( Data, FreeType );
VOID WINAPI
DnsRecordListFree(PDNS_RECORD Data,
DNS_FREE_TYPE FreeType)
{
DnsFree(Data, FreeType);
}

268
reactos/dll/win32/dnsapi/dnsapi/names.c
View file

@ -3,16 +3,22 @@
#define NDEBUG
#include <debug.h>
static BOOL DnsIntNameContainsDots( LPCWSTR Name ) {
return wcschr( Name, '.' ) ? TRUE : FALSE;
static BOOL
DnsIntNameContainsDots(LPCWSTR Name)
{
return wcschr(Name, '.') ? TRUE : FALSE;
}
static BOOL DnsIntTwoConsecutiveDots( LPCWSTR Name ) {
return wcsstr( Name, L".." ) ? TRUE : FALSE;
static BOOL
DnsIntTwoConsecutiveDots(LPCWSTR Name)
{
return wcsstr(Name, L"..") ? TRUE : FALSE;
}
static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) {
return wcschr( Name, '_' ) ? TRUE : FALSE;
static BOOL
DnsIntContainsUnderscore(LPCWSTR Name)
{
return wcschr(Name, '_') ? TRUE : FALSE;
}
/* DnsValidateName *********************
@ -47,113 +53,126 @@ static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) {
* If the name contains a non-ascii character.
*/
DNS_STATUS WINAPI DnsValidateName_W
( LPCWSTR Name,
DNS_NAME_FORMAT Format ) {
BOOL AllowDot = FALSE;
BOOL AllowLeadingAst = FALSE;
BOOL AllowLeadingUnderscore = FALSE;
BOOL AllowAllDigits = FALSE;
const WCHAR *NextLabel, *CurrentLabel, *CurrentChar;
switch( Format ) {
case DnsNameDomain:
AllowAllDigits = TRUE;
AllowDot = TRUE;
break;
case DnsNameDomainLabel:
AllowAllDigits = TRUE;
break;
case DnsNameHostnameFull:
AllowDot = TRUE;
break;
case DnsNameHostnameLabel:
break;
case DnsNameWildcard:
AllowLeadingAst = TRUE;
AllowDot = TRUE;
break;
case DnsNameSrvRecord:
AllowLeadingUnderscore = TRUE;
break;
default:
break;
}
DNS_STATUS WINAPI
DnsValidateName_W(LPCWSTR Name,
DNS_NAME_FORMAT Format)
{
BOOL AllowDot = FALSE;
BOOL AllowLeadingAst = FALSE;
BOOL AllowLeadingUnderscore = FALSE;
BOOL AllowAllDigits = FALSE;
const WCHAR *NextLabel, *CurrentLabel, *CurrentChar;
/* Preliminary checks */
if( Name[0] == 0 ) return ERROR_INVALID_NAME; /* XXX arty: Check this */
switch(Format)
{
case DnsNameDomain:
AllowAllDigits = TRUE;
AllowDot = TRUE;
break;
/* Name too long */
if( wcslen( Name ) > 255 ) {
return ERROR_INVALID_NAME;
}
/* Violations about dots */
if( (!AllowDot && DnsIntNameContainsDots( Name )) ||
Name[0] == '.' || DnsIntTwoConsecutiveDots( Name ) )
return ERROR_INVALID_NAME;
/* Check component sizes */
CurrentLabel = Name;
do {
NextLabel = CurrentLabel;
while( *NextLabel && *NextLabel != '.' ) NextLabel++;
case DnsNameDomainLabel:
AllowAllDigits = TRUE;
break;
if( NextLabel - CurrentLabel > 63 )
return ERROR_INVALID_NAME;
case DnsNameHostnameFull:
AllowDot = TRUE;
break;
CurrentLabel = NextLabel;
} while( *CurrentLabel );
case DnsNameHostnameLabel:
break;
CurrentChar = Name;
case DnsNameWildcard:
AllowLeadingAst = TRUE;
AllowDot = TRUE;
break;
while( *CurrentChar ) {
if( wcschr(L" {|}~[\\]^':;<=>?@!\"#$%^`()+/,",*CurrentChar) )
return DNS_ERROR_INVALID_NAME_CHAR;
CurrentChar++;
}
case DnsNameSrvRecord:
AllowLeadingUnderscore = TRUE;
break;
if( (!AllowLeadingAst && Name[0] == '*') ||
(AllowLeadingAst && Name[0] == '*' && Name[1] && Name[1] != '.') )
return DNS_ERROR_INVALID_NAME_CHAR;
default:
break;
}
if( wcschr( Name + 1, '*' ) )
return DNS_ERROR_INVALID_NAME_CHAR;
/* Preliminary checks */
if(Name[0] == 0)
return ERROR_INVALID_NAME; /* XXX arty: Check this */
CurrentChar = Name;
while( !AllowAllDigits && *CurrentChar ) {
if( *CurrentChar == '.' || (*CurrentChar >= '0' && *CurrentChar <= '9') )
return DNS_ERROR_NUMERIC_NAME;
}
/* Name too long */
if(wcslen(Name) > 255)
return ERROR_INVALID_NAME;
if( ((AllowLeadingUnderscore && Name[0] == '_') || Name[0] != '_') &&
!DnsIntContainsUnderscore( Name + 1 ) )
return DNS_ERROR_NON_RFC_NAME;
/* Violations about dots */
if((!AllowDot && DnsIntNameContainsDots(Name)) || Name[0] == '.' || DnsIntTwoConsecutiveDots(Name))
return ERROR_INVALID_NAME;
return ERROR_SUCCESS;
/* Check component sizes */
CurrentLabel = Name;
do
{
NextLabel = CurrentLabel;
while(*NextLabel && *NextLabel != '.')
NextLabel++;
if(NextLabel - CurrentLabel > 63)
return ERROR_INVALID_NAME;
CurrentLabel = NextLabel;
} while(*CurrentLabel);
CurrentChar = Name;
while(*CurrentChar)
{
if(wcschr(L" {|}~[\\]^':;<=>?@!\"#$%^`()+/,",*CurrentChar))
return DNS_ERROR_INVALID_NAME_CHAR;
CurrentChar++;
}
if((!AllowLeadingAst && Name[0] == '*') || (AllowLeadingAst && Name[0] == '*' && Name[1] && Name[1] != '.'))
return DNS_ERROR_INVALID_NAME_CHAR;
if(wcschr(Name + 1, '*'))
return DNS_ERROR_INVALID_NAME_CHAR;
CurrentChar = Name;
while(!AllowAllDigits && *CurrentChar)
{
if(*CurrentChar == '.' || (*CurrentChar >= '0' && *CurrentChar <= '9'))
return DNS_ERROR_NUMERIC_NAME;
}
if(((AllowLeadingUnderscore && Name[0] == '_') || Name[0] != '_') && !DnsIntContainsUnderscore(Name + 1))
return DNS_ERROR_NON_RFC_NAME;
return ERROR_SUCCESS;
}
DNS_STATUS WINAPI DnsValidateName_UTF8
( LPCSTR Name,
DNS_NAME_FORMAT Format ) {
PWCHAR Buffer;
int StrLenWc;
DNS_STATUS Status;
DNS_STATUS WINAPI
DnsValidateName_UTF8(LPCSTR Name,
DNS_NAME_FORMAT Format)
{
PWCHAR Buffer;
int StrLenWc;
DNS_STATUS Status;
StrLenWc = mbstowcs( NULL, Name, 0 );
Buffer = RtlAllocateHeap( GetProcessHeap(), 0,
sizeof( WCHAR ) * (StrLenWc + 1) );
mbstowcs( Buffer, Name, StrLenWc + 1 );
Status = DnsValidateName_W( Buffer, Format );
RtlFreeHeap( RtlGetProcessHeap(), 0, Buffer );
return Status;
StrLenWc = mbstowcs(NULL, Name, 0);
Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WCHAR) * (StrLenWc + 1));
mbstowcs(Buffer, Name, StrLenWc + 1);
Status = DnsValidateName_W(Buffer, Format);
RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
return Status;
}
DNS_STATUS WINAPI DnsValidateName_A
( LPCSTR Name,
DNS_NAME_FORMAT Format ) {
return DnsValidateName_UTF8( Name, Format );
DNS_STATUS WINAPI
DnsValidateName_A(LPCSTR Name,
DNS_NAME_FORMAT Format)
{
return DnsValidateName_UTF8(Name, Format);
}
/* DnsNameCompare **********************
@ -161,36 +180,39 @@ DNS_STATUS WINAPI DnsValidateName_A
*
* Name1 & Name2 -- Names.
*/
BOOL WINAPI
DnsNameCompare_W(LPWSTR Name1,
LPWSTR Name2)
{
int offset = 0;
BOOL WINAPI DnsNameCompare_W
( LPWSTR Name1,
LPWSTR Name2 ) {
int offset = 0;
while(Name1[offset] && Name2[offset] && towupper(Name1[offset]) == towupper(Name2[offset]))
offset++;
while( Name1[offset] && Name2[offset] &&
towupper( Name1[offset] ) == towupper( Name2[offset] ) ) offset++;
return
(!Name1[offset] && !Name2[offset]) ||
(!Name1[offset] && !wcscmp( Name2 + offset, L"." )) ||
(!Name2[offset] && !wcscmp( Name1 + offset, L"." ));
return
(!Name1[offset] && !Name2[offset]) ||
(!Name1[offset] && !wcscmp(Name2 + offset, L".")) ||
(!Name2[offset] && !wcscmp(Name1 + offset, L"."));
}
BOOL WINAPI DnsNameCompare_UTF8
( LPCSTR Name1,
LPCSTR Name2 ) {
int offset = 0;
while( Name1[offset] && Name2[offset] &&
toupper( Name1[offset] ) == toupper( Name2[offset] ) ) offset++;
return
(!Name1[offset] && !Name2[offset]) ||
(!Name1[offset] && !strcmp( Name2 + offset, ".")) ||
(!Name2[offset] && !strcmp( Name1 + offset, "."));
BOOL WINAPI
DnsNameCompare_UTF8(LPCSTR Name1,
LPCSTR Name2)
{
int offset = 0;
while(Name1[offset] && Name2[offset] && toupper(Name1[offset]) == toupper(Name2[offset]))
offset++;
return
(!Name1[offset] && !Name2[offset]) ||
(!Name1[offset] && !strcmp(Name2 + offset, ".")) ||
(!Name2[offset] && !strcmp(Name1 + offset, "."));
}
BOOL WINAPI DnsNameCompare_A
( LPSTR Name1,
LPSTR Name2 ) {
return DnsNameCompare_UTF8( Name1, Name2 );
BOOL WINAPI
DnsNameCompare_A(LPSTR Name1,
LPSTR Name2)
{
return DnsNameCompare_UTF8(Name1, Name2);
}

559
reactos/dll/win32/dnsapi/dnsapi/query.c
View file

@ -31,312 +31,317 @@
* Reserved -- Response as it appears on the wire. Optional.
*/
char *xstrsave(const char *str) {
char *p;
char
*xstrsave(const char *str)
{
char *p;
p = RtlAllocateHeap( RtlGetProcessHeap(), 0, strlen(str)+1 );
if ( NULL != p ) {
strcpy(p,str);
}
return p;
p = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(str) + 1);
if(p)
strcpy(p, str);
return p;
}
DNS_STATUS WINAPI DnsQuery_A
( LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
adns_state astate;
int quflags = 0, i;
int adns_error;
adns_answer *answer;
LPSTR CurrentName;
unsigned CNameLoop;
DNS_STATUS WINAPI
DnsQuery_A(LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved)
{
adns_state astate;
int quflags = 0, i;
int adns_error;
adns_answer *answer;
LPSTR CurrentName;
unsigned CNameLoop;
*QueryResultSet = 0;
*QueryResultSet = 0;
switch( Type ) {
case DNS_TYPE_A:
adns_error = adns_init( &astate,
adns_if_noenv |
adns_if_noerrprint |
adns_if_noserverwarn |
(Servers ? adns_if_noserver : 0),
0 );
switch(Type)
{
case DNS_TYPE_A:
adns_error = adns_init(&astate, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn | (Servers ? adns_if_noserver : 0), 0);
if( adns_error != adns_s_ok ) {
return DnsIntTranslateAdnsToDNS_STATUS( adns_error );
}
if(adns_error != adns_s_ok)
return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
if (Servers) {
for( i = 0; i < Servers->AddrCount; i++ ) {
adns_addserver( astate, *((struct in_addr *)&Servers->AddrArray[i]) );
}
}
if (Servers)
{
for(i = 0; i < Servers->AddrCount; i++)
{
adns_addserver(astate, *((struct in_addr *)&Servers->AddrArray[i]));
}
}
/*
* adns doesn't resolve chained CNAME records (a CNAME which points to
* another CNAME pointing to another... pointing to an A record), according
* to a mailing list thread the authors believe that chained CNAME records
* are invalid and the DNS entries should be fixed. That's a nice academic
* standpoint, but there certainly are chained CNAME records out there,
* even some fairly major ones (at the time of this writing
* download.mozilla.org is a chained CNAME). Everyone else seems to resolve
* these fine, so we should too. So we loop here to try to resolve CNAME
* chains ourselves. Of course, there must be a limit to protect against
* CNAME loops.
*/
/*
* adns doesn't resolve chained CNAME records (a CNAME which points to
* another CNAME pointing to another... pointing to an A record), according
* to a mailing list thread the authors believe that chained CNAME records
* are invalid and the DNS entries should be fixed. That's a nice academic
* standpoint, but there certainly are chained CNAME records out there,
* even some fairly major ones (at the time of this writing
* download.mozilla.org is a chained CNAME). Everyone else seems to resolve
* these fine, so we should too. So we loop here to try to resolve CNAME
* chains ourselves. Of course, there must be a limit to protect against
* CNAME loops.
*/
#define CNAME_LOOP_MAX 16
CurrentName = (LPSTR) Name;
for ( CNameLoop = 0; CNameLoop < CNAME_LOOP_MAX; CNameLoop++ ) {
adns_error = adns_synchronous( astate,
CurrentName,
adns_r_addr,
quflags,
&answer );
CurrentName = (LPSTR) Name;
if( adns_error != adns_s_ok ) {
adns_finish( astate );
if ( CurrentName != Name ) {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
}
return DnsIntTranslateAdnsToDNS_STATUS( adns_error );
}
for (CNameLoop = 0; CNameLoop < CNAME_LOOP_MAX; CNameLoop++)
{
adns_error = adns_synchronous(astate, CurrentName, adns_r_addr, quflags, &answer);
if( answer && answer->rrs.addr ) {
if ( CurrentName != Name ) {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
}
*QueryResultSet =
(PDNS_RECORD)RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof( DNS_RECORD ) );
if ( NULL == *QueryResultSet ) {
adns_finish( astate );
return ERROR_OUTOFMEMORY;
}
(*QueryResultSet)->pNext = NULL;
(*QueryResultSet)->wType = Type;
(*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA);
(*QueryResultSet)->Data.A.IpAddress =
answer->rrs.addr->addr.inet.sin_addr.s_addr;
adns_finish( astate );
(*QueryResultSet)->pName = xstrsave( Name );
return NULL != (*QueryResultSet)->pName ? ERROR_SUCCESS :
ERROR_OUTOFMEMORY;
}
if ( NULL == answer || adns_s_prohibitedcname != answer->status ||
NULL == answer->cname ) {
adns_finish( astate );
if ( CurrentName != Name ) {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
}
return ERROR_FILE_NOT_FOUND;
}
if ( CurrentName != Name ) {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
}
CurrentName = xstrsave( answer->cname );
if ( NULL == CurrentName ) {
adns_finish( astate );
return ERROR_OUTOFMEMORY;
}
if(adns_error != adns_s_ok)
{
adns_finish(astate);
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
}
if(answer && answer->rrs.addr)
{
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
*QueryResultSet = (PDNS_RECORD)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
if (NULL == *QueryResultSet)
{
adns_finish( astate );
return ERROR_OUTOFMEMORY;
}
(*QueryResultSet)->pNext = NULL;
(*QueryResultSet)->wType = Type;
(*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA);
(*QueryResultSet)->Data.A.IpAddress = answer->rrs.addr->addr.inet.sin_addr.s_addr;
adns_finish(astate);
(*QueryResultSet)->pName = xstrsave( Name );
return NULL != (*QueryResultSet)->pName ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
}
if (NULL == answer || adns_s_prohibitedcname != answer->status || NULL == answer->cname)
{
adns_finish(astate);
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
return ERROR_FILE_NOT_FOUND;
}
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
CurrentName = xstrsave(answer->cname);
if (!CurrentName)
{
adns_finish(astate);
return ERROR_OUTOFMEMORY;
}
}
adns_finish(astate);
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
return ERROR_FILE_NOT_FOUND;
default:
return ERROR_OUTOFMEMORY; /* XXX arty: find a better error code. */
}
adns_finish( astate );
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
return ERROR_FILE_NOT_FOUND;
default:
return ERROR_OUTOFMEMORY; /* XXX arty: find a better error code. */
}
}
static PCHAR DnsWToC( const WCHAR *WideString ) {
int chars = wcstombs( NULL, WideString, 0 );
PCHAR out = RtlAllocateHeap( RtlGetProcessHeap(), 0, chars + 1 );
wcstombs( out, WideString, chars + 1 );
return out;
static PCHAR
DnsWToC(const WCHAR *WideString)
{
int chars = wcstombs(NULL, WideString, 0);
PCHAR out = RtlAllocateHeap(RtlGetProcessHeap(), 0, chars + 1);
wcstombs(out, WideString, chars + 1);
return out;
}
static PWCHAR DnsCToW( const CHAR *NarrowString ) {
int chars = mbstowcs( NULL, NarrowString, 0 );
PWCHAR out = RtlAllocateHeap( RtlGetProcessHeap(), 0,
(chars + 1) * sizeof(WCHAR) );
mbstowcs( out, NarrowString, chars + 1 );
return out;
static PWCHAR
DnsCToW(const CHAR *NarrowString)
{
int chars = mbstowcs(NULL, NarrowString, 0);
PWCHAR out = RtlAllocateHeap(RtlGetProcessHeap(), 0, (chars + 1) * sizeof(WCHAR));
mbstowcs(out, NarrowString, chars + 1);
return out;
}
DNS_STATUS WINAPI DnsQuery_W
( LPCWSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
UINT i;
PCHAR Buffer;
DNS_STATUS Status;
PDNS_RECORD QueryResultWide;
PDNS_RECORD ConvertedRecord = 0, LastRecord = 0;
DNS_STATUS WINAPI
DnsQuery_W(LPCWSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved)
{
UINT i;
PCHAR Buffer;
DNS_STATUS Status;
PDNS_RECORD QueryResultWide;
PDNS_RECORD ConvertedRecord = 0, LastRecord = 0;
Buffer = DnsWToC( Name );
Buffer = DnsWToC(Name);
Status = DnsQuery_A( Buffer, Type, Options, Servers, &QueryResultWide,
Reserved );
Status = DnsQuery_A(Buffer, Type, Options, Servers, &QueryResultWide, Reserved);
while( Status == ERROR_SUCCESS && QueryResultWide ) {
switch( QueryResultWide->wType ) {
case DNS_TYPE_A:
case DNS_TYPE_WKS:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = QueryResultWide->wDataLength;
memcpy( ConvertedRecord, QueryResultWide,
QueryResultWide->wDataLength );
break;
while(Status == ERROR_SUCCESS && QueryResultWide)
{
switch(QueryResultWide->wType)
{
case DNS_TYPE_A:
case DNS_TYPE_WKS:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = QueryResultWide->wDataLength;
memcpy(ConvertedRecord, QueryResultWide, QueryResultWide->wDataLength);
break;
case DNS_TYPE_CNAME:
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
case DNS_TYPE_MB:
case DNS_TYPE_MD:
case DNS_TYPE_MF:
case DNS_TYPE_MG:
case DNS_TYPE_MR:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_PTR_DATA);
ConvertedRecord->Data.PTR.pNameHost =
(PCHAR)DnsCToW( QueryResultWide->Data.PTR.pNameHost );
break;
case DNS_TYPE_MINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_MINFO_DATA);
ConvertedRecord->Data.MINFO.pNameMailbox =
(PCHAR)DnsCToW( QueryResultWide->Data.MINFO.pNameMailbox );
ConvertedRecord->Data.MINFO.pNameErrorsMailbox =
(PCHAR)DnsCToW( QueryResultWide->Data.MINFO.pNameErrorsMailbox );
break;
case DNS_TYPE_CNAME:
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
case DNS_TYPE_MB:
case DNS_TYPE_MD:
case DNS_TYPE_MF:
case DNS_TYPE_MG:
case DNS_TYPE_MR:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_PTR_DATA);
ConvertedRecord->Data.PTR.pNameHost = (PCHAR)DnsCToW(QueryResultWide->Data.PTR.pNameHost);
break;
case DNS_TYPE_MX:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_MX_DATA);
ConvertedRecord->Data.MX.pNameExchange =
(PCHAR)DnsCToW( QueryResultWide->Data.MX.pNameExchange );
ConvertedRecord->Data.MX.wPreference =
QueryResultWide->Data.MX.wPreference;
break;
case DNS_TYPE_MINFO:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_MINFO_DATA);
ConvertedRecord->Data.MINFO.pNameMailbox = (PCHAR)DnsCToW(QueryResultWide->Data.MINFO.pNameMailbox);
ConvertedRecord->Data.MINFO.pNameErrorsMailbox = (PCHAR)DnsCToW(QueryResultWide->Data.MINFO.pNameErrorsMailbox);
break;
case DNS_TYPE_HINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_TXT_DATA) +
QueryResultWide->
Data.TXT.dwStringCount );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength =
sizeof(DNS_TXT_DATA) +
(sizeof(PWCHAR) * QueryResultWide->Data.TXT.dwStringCount);
ConvertedRecord->Data.TXT.dwStringCount =
QueryResultWide->Data.TXT.dwStringCount;
for( i = 0; i < ConvertedRecord->Data.TXT.dwStringCount; i++ ) {
ConvertedRecord->Data.TXT.pStringArray[i] =
(PCHAR)DnsCToW( QueryResultWide->Data.TXT.pStringArray[i] );
}
break;
case DNS_TYPE_MX:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_MX_DATA);
ConvertedRecord->Data.MX.pNameExchange = (PCHAR)DnsCToW( QueryResultWide->Data.MX.pNameExchange);
ConvertedRecord->Data.MX.wPreference = QueryResultWide->Data.MX.wPreference;
break;
case DNS_TYPE_NULL:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_NULL_DATA) +
QueryResultWide->
Data.Null.dwByteCount );
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength =
sizeof(DNS_NULL_DATA) + QueryResultWide->Data.Null.dwByteCount;
ConvertedRecord->Data.Null.dwByteCount =
QueryResultWide->Data.Null.dwByteCount;
memcpy( &ConvertedRecord->Data.Null.Data,
&QueryResultWide->Data.Null.Data,
QueryResultWide->Data.Null.dwByteCount );
break;
case DNS_TYPE_HINFO:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_TXT_DATA) + QueryResultWide->Data.TXT.dwStringCount);
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_TXT_DATA) + (sizeof(PWCHAR) * QueryResultWide->Data.TXT.dwStringCount);
ConvertedRecord->Data.TXT.dwStringCount = QueryResultWide->Data.TXT.dwStringCount;
for(i = 0; i < ConvertedRecord->Data.TXT.dwStringCount; i++)
ConvertedRecord->Data.TXT.pStringArray[i] = (PCHAR)DnsCToW(QueryResultWide->Data.TXT.pStringArray[i]);
break;
case DNS_TYPE_NULL:
ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_NULL_DATA) + QueryResultWide->Data.Null.dwByteCount);
ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wDataLength = sizeof(DNS_NULL_DATA) + QueryResultWide->Data.Null.dwByteCount;
ConvertedRecord->Data.Null.dwByteCount = QueryResultWide->Data.Null.dwByteCount;
memcpy(&ConvertedRecord->Data.Null.Data, &QueryResultWide->Data.Null.Data, QueryResultWide->Data.Null.dwByteCount);
break;
}
if(LastRecord)
{
LastRecord->pNext = ConvertedRecord;
LastRecord = LastRecord->pNext;
}
else
{
LastRecord = *QueryResultSet = ConvertedRecord;
}
}
if( LastRecord ) {
LastRecord->pNext = ConvertedRecord;
LastRecord = LastRecord->pNext;
} else {
LastRecord = *QueryResultSet = ConvertedRecord;
LastRecord->pNext = 0;
/* The name */
RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
return Status;
}
DNS_STATUS WINAPI
DnsQuery_UTF8(LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved)
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
void
DnsIntFreeRecordList(PDNS_RECORD ToDelete)
{
UINT i;
PDNS_RECORD next = 0;
while(ToDelete)
{
if(ToDelete->pName)
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->pName);
switch(ToDelete->wType)
{
case DNS_TYPE_CNAME:
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
case DNS_TYPE_MB:
case DNS_TYPE_MD:
case DNS_TYPE_MF:
case DNS_TYPE_MG:
case DNS_TYPE_MR:
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.PTR.pNameHost);
break;
case DNS_TYPE_MINFO:
case DNS_TYPE_MX:
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.MX.pNameExchange);
break;
case DNS_TYPE_HINFO:
for(i = 0; i < ToDelete->Data.TXT.dwStringCount; i++)
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.TXT.pStringArray[i]);
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.TXT.pStringArray);
break;
}
next = ToDelete->pNext;
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete);
ToDelete = next;
}
}
LastRecord->pNext = 0;
/* The name */
RtlFreeHeap( RtlGetProcessHeap(), 0, Buffer );
return Status;
}
DNS_STATUS WINAPI DnsQuery_UTF8
( LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
void DnsIntFreeRecordList( PDNS_RECORD ToDelete ) {
UINT i;
PDNS_RECORD next = 0;
while( ToDelete ) {
if( ToDelete->pName )
RtlFreeHeap( RtlGetProcessHeap(), 0, ToDelete->pName );
switch( ToDelete->wType ) {
case DNS_TYPE_CNAME:
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
case DNS_TYPE_MB:
case DNS_TYPE_MD:
case DNS_TYPE_MF:
case DNS_TYPE_MG:
case DNS_TYPE_MR:
RtlFreeHeap( RtlGetProcessHeap(), 0, ToDelete->Data.PTR.pNameHost );
break;
case DNS_TYPE_MINFO:
case DNS_TYPE_MX:
RtlFreeHeap( RtlGetProcessHeap(), 0, ToDelete->Data.MX.pNameExchange );
break;
case DNS_TYPE_HINFO:
for( i = 0; i < ToDelete->Data.TXT.dwStringCount; i++ ) {
RtlFreeHeap( RtlGetProcessHeap(), 0,
ToDelete->Data.TXT.pStringArray[i] );
}
RtlFreeHeap( RtlGetProcessHeap(), 0, ToDelete->Data.TXT.pStringArray );
break;
}
next = ToDelete->pNext;
RtlFreeHeap( RtlGetProcessHeap(), 0, ToDelete );
ToDelete = next;
}
}

920
reactos/dll/win32/dnsapi/dnsapi/stubs.c
View file

File diff suppressed because it is too large Load diff

9
reactos/dll/win32/dnsapi/include/internal/windns.h
View file

@ -3,11 +3,12 @@
#include "adns.h"
typedef struct {
adns_state State;
typedef struct
{
adns_state State;
} WINDNS_CONTEXT, *PWINDNS_CONTEXT;
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS( int Status );
void DnsIntFreeRecordList( PDNS_RECORD ToFree );
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS(int Status);
void DnsIntFreeRecordList(PDNS_RECORD ToFree);
#endif//WINDNS_INTERNAL_H