Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 21:42:57 +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
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 #define NDEBUG
#include <debug.h> #include <debug.h>
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS( int Status ) { DNS_STATUS
switch( Status ) { DnsIntTranslateAdnsToDNS_STATUS(int Status)
case adns_s_ok: {
return ERROR_SUCCESS; switch(Status)
case adns_s_nomemory: {
case adns_s_systemfail: case adns_s_ok:
default: /* There really aren't any general errors in the dns part. */ return ERROR_SUCCESS;
return ERROR_OUTOFMEMORY;
}
}
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? * TODO: Which ones area allowed?
*/ */
extern DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8 extern DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8(DWORD CredentialsFlags, PVOID Credentials, HANDLE *ContextHandle);
( DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle );
DNS_STATUS WINAPI DnsAcquireContextHandle_W DNS_STATUS WINAPI
( DWORD CredentialsFlags, DnsAcquireContextHandle_W(DWORD CredentialsFlags,
PVOID Credentials, PVOID Credentials,
HANDLE *ContextHandle ) { HANDLE *ContextHandle)
if( CredentialsFlags ) { {
PWINDNS_CONTEXT Context; if(CredentialsFlags)
int adns_status; {
PWINDNS_CONTEXT Context;
int adns_status;
/* For now, don't worry about the user's identity. */ /* For now, don't worry about the user's identity. */
Context = (PWINDNS_CONTEXT)RtlAllocateHeap( RtlGetProcessHeap(), 0, Context = (PWINDNS_CONTEXT)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WINDNS_CONTEXT));
sizeof( WINDNS_CONTEXT ) );
if(!Context){ if(!Context)
*ContextHandle = 0; {
return ERROR_OUTOFMEMORY; *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;
}
} }
else
/* The real work here is to create an adns_state that will help us {
* do what we want to later. */ return DnsAcquireContextHandle_UTF8(CredentialsFlags, Credentials, ContextHandle);
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 );
}
} }
DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8 DNS_STATUS WINAPI
( DWORD CredentialsFlags, DnsAcquireContextHandle_UTF8(DWORD CredentialsFlags,
PVOID Credentials, PVOID Credentials,
HANDLE *ContextHandle ) { HANDLE *ContextHandle)
if( CredentialsFlags ) { {
return DnsAcquireContextHandle_W( CredentialsFlags, if( CredentialsFlags )
Credentials, {
ContextHandle ); return DnsAcquireContextHandle_W(CredentialsFlags, Credentials, ContextHandle);
} else { }
/* Convert to unicode, then call the _W version else
* For now, there is no conversion */ {
DNS_STATUS Status; /* Convert to unicode, then call the _W version
* For now, there is no conversion */
DNS_STATUS Status;
Status = DnsAcquireContextHandle_W( TRUE, Status = DnsAcquireContextHandle_W(TRUE, Credentials, /* XXX arty */ ContextHandle);
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 DNS_STATUS WINAPI
( DWORD CredentialFlags, DnsAcquireContextHandle_A(DWORD CredentialFlags,
PVOID Credentials, PVOID Credentials,
HANDLE *ContextHandle ) { HANDLE *ContextHandle)
if( CredentialFlags ) { {
return DnsAcquireContextHandle_W( CredentialFlags, if(CredentialFlags)
Credentials, {
ContextHandle ); return DnsAcquireContextHandle_W(CredentialFlags, Credentials, ContextHandle);
} else { }
return DnsAcquireContextHandle_UTF8( CredentialFlags, else
Credentials, {
ContextHandle ); return DnsAcquireContextHandle_UTF8(CredentialFlags, Credentials, ContextHandle);
} }
} }
/* DnsReleaseContextHandle ************* /* DnsReleaseContextHandle *************
* Release a context handle, freeing all resources. * Release a context handle, freeing all resources.
*/ */
void WINAPI
DnsReleaseContextHandle(HANDLE ContextHandle)
{
PWINDNS_CONTEXT Context = (PWINDNS_CONTEXT)ContextHandle;
void WINAPI DnsReleaseContextHandle adns_finish(Context->State);
( HANDLE ContextHandle ) { RtlFreeHeap(RtlGetProcessHeap(), 0, Context);
PWINDNS_CONTEXT Context = (PWINDNS_CONTEXT)ContextHandle;
adns_finish( Context->State );
RtlFreeHeap( RtlGetProcessHeap(), 0, Context );
} }

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

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

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

@ -3,16 +3,22 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
static BOOL DnsIntNameContainsDots( LPCWSTR Name ) { static BOOL
return wcschr( Name, '.' ) ? TRUE : FALSE; DnsIntNameContainsDots(LPCWSTR Name)
{
return wcschr(Name, '.') ? TRUE : FALSE;
} }
static BOOL DnsIntTwoConsecutiveDots( LPCWSTR Name ) { static BOOL
return wcsstr( Name, L".." ) ? TRUE : FALSE; DnsIntTwoConsecutiveDots(LPCWSTR Name)
{
return wcsstr(Name, L"..") ? TRUE : FALSE;
} }
static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) { static BOOL
return wcschr( Name, '_' ) ? TRUE : FALSE; DnsIntContainsUnderscore(LPCWSTR Name)
{
return wcschr(Name, '_') ? TRUE : FALSE;
} }
/* DnsValidateName ********************* /* DnsValidateName *********************
@ -47,113 +53,126 @@ static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) {
* If the name contains a non-ascii character. * If the name contains a non-ascii character.
*/ */
DNS_STATUS WINAPI DnsValidateName_W DNS_STATUS WINAPI
( LPCWSTR Name, DnsValidateName_W(LPCWSTR Name,
DNS_NAME_FORMAT Format ) { DNS_NAME_FORMAT Format)
BOOL AllowDot = FALSE; {
BOOL AllowLeadingAst = FALSE; BOOL AllowDot = FALSE;
BOOL AllowLeadingUnderscore = FALSE; BOOL AllowLeadingAst = FALSE;
BOOL AllowAllDigits = FALSE; BOOL AllowLeadingUnderscore = FALSE;
const WCHAR *NextLabel, *CurrentLabel, *CurrentChar; BOOL AllowAllDigits = FALSE;
const WCHAR *NextLabel, *CurrentLabel, *CurrentChar;
switch( Format ) { switch(Format)
case DnsNameDomain: {
AllowAllDigits = TRUE; case DnsNameDomain:
AllowDot = TRUE; AllowAllDigits = TRUE;
break; AllowDot = TRUE;
case DnsNameDomainLabel: break;
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;
}
/* Preliminary checks */ case DnsNameDomainLabel:
if( Name[0] == 0 ) return ERROR_INVALID_NAME; /* XXX arty: Check this */ AllowAllDigits = TRUE;
break;
/* Name too long */ case DnsNameHostnameFull:
if( wcslen( Name ) > 255 ) { AllowDot = TRUE;
return ERROR_INVALID_NAME; break;
}
/* Violations about dots */ case DnsNameHostnameLabel:
if( (!AllowDot && DnsIntNameContainsDots( Name )) || break;
Name[0] == '.' || DnsIntTwoConsecutiveDots( Name ) )
return ERROR_INVALID_NAME;
/* Check component sizes */ case DnsNameWildcard:
CurrentLabel = Name; AllowLeadingAst = TRUE;
do { AllowDot = TRUE;
NextLabel = CurrentLabel; break;
while( *NextLabel && *NextLabel != '.' ) NextLabel++;
if( NextLabel - CurrentLabel > 63 ) case DnsNameSrvRecord:
return ERROR_INVALID_NAME; AllowLeadingUnderscore = TRUE;
break;
CurrentLabel = NextLabel; default:
} while( *CurrentLabel ); break;
}
CurrentChar = Name; /* Preliminary checks */
if(Name[0] == 0)
return ERROR_INVALID_NAME; /* XXX arty: Check this */
while( *CurrentChar ) { /* Name too long */
if( wcschr(L" {|}~[\\]^':;<=>?@!\"#$%^`()+/,",*CurrentChar) ) if(wcslen(Name) > 255)
return DNS_ERROR_INVALID_NAME_CHAR; return ERROR_INVALID_NAME;
CurrentChar++;
}
if( (!AllowLeadingAst && Name[0] == '*') || /* Violations about dots */
(AllowLeadingAst && Name[0] == '*' && Name[1] && Name[1] != '.') ) if((!AllowDot && DnsIntNameContainsDots(Name)) || Name[0] == '.' || DnsIntTwoConsecutiveDots(Name))
return DNS_ERROR_INVALID_NAME_CHAR; return ERROR_INVALID_NAME;
if( wcschr( Name + 1, '*' ) ) /* Check component sizes */
return DNS_ERROR_INVALID_NAME_CHAR; CurrentLabel = Name;
CurrentChar = Name; do
while( !AllowAllDigits && *CurrentChar ) { {
if( *CurrentChar == '.' || (*CurrentChar >= '0' && *CurrentChar <= '9') ) NextLabel = CurrentLabel;
return DNS_ERROR_NUMERIC_NAME; while(*NextLabel && *NextLabel != '.')
} NextLabel++;
if( ((AllowLeadingUnderscore && Name[0] == '_') || Name[0] != '_') && if(NextLabel - CurrentLabel > 63)
!DnsIntContainsUnderscore( Name + 1 ) ) return ERROR_INVALID_NAME;
return DNS_ERROR_NON_RFC_NAME;
return ERROR_SUCCESS; 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 DNS_STATUS WINAPI
( LPCSTR Name, DnsValidateName_UTF8(LPCSTR Name,
DNS_NAME_FORMAT Format ) { DNS_NAME_FORMAT Format)
PWCHAR Buffer; {
int StrLenWc; PWCHAR Buffer;
DNS_STATUS Status; int StrLenWc;
DNS_STATUS Status;
StrLenWc = mbstowcs( NULL, Name, 0 ); StrLenWc = mbstowcs(NULL, Name, 0);
Buffer = RtlAllocateHeap( GetProcessHeap(), 0, Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WCHAR) * (StrLenWc + 1));
sizeof( WCHAR ) * (StrLenWc + 1) ); mbstowcs(Buffer, Name, StrLenWc + 1);
mbstowcs( Buffer, Name, StrLenWc + 1 ); Status = DnsValidateName_W(Buffer, Format);
Status = DnsValidateName_W( Buffer, Format ); RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
RtlFreeHeap( RtlGetProcessHeap(), 0, Buffer );
return Status; return Status;
} }
DNS_STATUS WINAPI DnsValidateName_A DNS_STATUS WINAPI
( LPCSTR Name, DnsValidateName_A(LPCSTR Name,
DNS_NAME_FORMAT Format ) { DNS_NAME_FORMAT Format)
return DnsValidateName_UTF8( Name, Format ); {
return DnsValidateName_UTF8(Name, Format);
} }
/* DnsNameCompare ********************** /* DnsNameCompare **********************
@ -161,36 +180,39 @@ DNS_STATUS WINAPI DnsValidateName_A
* *
* Name1 & Name2 -- Names. * Name1 & Name2 -- Names.
*/ */
BOOL WINAPI
DnsNameCompare_W(LPWSTR Name1,
LPWSTR Name2)
{
int offset = 0;
BOOL WINAPI DnsNameCompare_W while(Name1[offset] && Name2[offset] && towupper(Name1[offset]) == towupper(Name2[offset]))
( LPWSTR Name1, offset++;
LPWSTR Name2 ) {
int offset = 0;
while( Name1[offset] && Name2[offset] && return
towupper( Name1[offset] ) == towupper( Name2[offset] ) ) offset++; (!Name1[offset] && !Name2[offset]) ||
return (!Name1[offset] && !wcscmp(Name2 + offset, L".")) ||
(!Name1[offset] && !Name2[offset]) || (!Name2[offset] && !wcscmp(Name1 + offset, L"."));
(!Name1[offset] && !wcscmp( Name2 + offset, L"." )) ||
(!Name2[offset] && !wcscmp( Name1 + offset, L"." ));
} }
BOOL WINAPI DnsNameCompare_UTF8 BOOL WINAPI
( LPCSTR Name1, DnsNameCompare_UTF8(LPCSTR Name1,
LPCSTR Name2 ) { LPCSTR Name2)
int offset = 0; {
int offset = 0;
while( Name1[offset] && Name2[offset] && while(Name1[offset] && Name2[offset] && toupper(Name1[offset]) == toupper(Name2[offset]))
toupper( Name1[offset] ) == toupper( Name2[offset] ) ) offset++; offset++;
return
(!Name1[offset] && !Name2[offset]) || return
(!Name1[offset] && !strcmp( Name2 + offset, ".")) || (!Name1[offset] && !Name2[offset]) ||
(!Name2[offset] && !strcmp( Name1 + offset, ".")); (!Name1[offset] && !strcmp(Name2 + offset, ".")) ||
(!Name2[offset] && !strcmp(Name1 + offset, "."));
} }
BOOL WINAPI DnsNameCompare_A BOOL WINAPI
( LPSTR Name1, DnsNameCompare_A(LPSTR Name1,
LPSTR Name2 ) { LPSTR Name2)
return DnsNameCompare_UTF8( Name1, 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. * Reserved -- Response as it appears on the wire. Optional.
*/ */
char *xstrsave(const char *str) { char
char *p; *xstrsave(const char *str)
{
char *p;
p = RtlAllocateHeap( RtlGetProcessHeap(), 0, strlen(str)+1 ); p = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(str) + 1);
if ( NULL != p ) {
strcpy(p,str); if(p)
} strcpy(p, str);
return p;
return p;
} }
DNS_STATUS WINAPI DnsQuery_A DNS_STATUS WINAPI
( LPCSTR Name, DnsQuery_A(LPCSTR Name,
WORD Type, WORD Type,
DWORD Options, DWORD Options,
PIP4_ARRAY Servers, PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet, PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) { PVOID *Reserved)
adns_state astate; {
int quflags = 0, i; adns_state astate;
int adns_error; int quflags = 0, i;
adns_answer *answer; int adns_error;
LPSTR CurrentName; adns_answer *answer;
unsigned CNameLoop; LPSTR CurrentName;
unsigned CNameLoop;
*QueryResultSet = 0; *QueryResultSet = 0;
switch( Type ) { switch(Type)
case DNS_TYPE_A: {
adns_error = adns_init( &astate, case DNS_TYPE_A:
adns_if_noenv | adns_error = adns_init(&astate, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn | (Servers ? adns_if_noserver : 0), 0);
adns_if_noerrprint |
adns_if_noserverwarn |
(Servers ? adns_if_noserver : 0),
0 );
if( adns_error != adns_s_ok ) { if(adns_error != adns_s_ok)
return DnsIntTranslateAdnsToDNS_STATUS( adns_error ); return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
}
if (Servers) { if (Servers)
for( i = 0; i < Servers->AddrCount; i++ ) { {
adns_addserver( astate, *((struct in_addr *)&Servers->AddrArray[i]) ); 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 * adns doesn't resolve chained CNAME records (a CNAME which points to
* another CNAME pointing to another... pointing to an A record), according * another CNAME pointing to another... pointing to an A record), according
* to a mailing list thread the authors believe that chained CNAME records * 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 * are invalid and the DNS entries should be fixed. That's a nice academic
* standpoint, but there certainly are chained CNAME records out there, * standpoint, but there certainly are chained CNAME records out there,
* even some fairly major ones (at the time of this writing * even some fairly major ones (at the time of this writing
* download.mozilla.org is a chained CNAME). Everyone else seems to resolve * 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 * 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 * chains ourselves. Of course, there must be a limit to protect against
* CNAME loops. * CNAME loops.
*/ */
#define CNAME_LOOP_MAX 16 #define CNAME_LOOP_MAX 16
CurrentName = (LPSTR) Name; CurrentName = (LPSTR) Name;
for ( CNameLoop = 0; CNameLoop < CNAME_LOOP_MAX; CNameLoop++ ) {
adns_error = adns_synchronous( astate,
CurrentName,
adns_r_addr,
quflags,
&answer );
if( adns_error != adns_s_ok ) { for (CNameLoop = 0; CNameLoop < CNAME_LOOP_MAX; CNameLoop++)
adns_finish( astate ); {
if ( CurrentName != Name ) { adns_error = adns_synchronous(astate, CurrentName, adns_r_addr, quflags, &answer);
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName );
}
return DnsIntTranslateAdnsToDNS_STATUS( adns_error );
}
if( answer && answer->rrs.addr ) { if(adns_error != adns_s_ok)
if ( CurrentName != Name ) { {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName ); adns_finish(astate);
}
*QueryResultSet = if (CurrentName != Name)
(PDNS_RECORD)RtlAllocateHeap( RtlGetProcessHeap(), 0, RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
sizeof( DNS_RECORD ) );
if ( NULL == *QueryResultSet ) { return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
adns_finish( astate ); }
return ERROR_OUTOFMEMORY;
} if(answer && answer->rrs.addr)
(*QueryResultSet)->pNext = NULL; {
(*QueryResultSet)->wType = Type; if (CurrentName != Name)
(*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA); RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
(*QueryResultSet)->Data.A.IpAddress =
answer->rrs.addr->addr.inet.sin_addr.s_addr; *QueryResultSet = (PDNS_RECORD)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
adns_finish( astate );
(*QueryResultSet)->pName = xstrsave( Name ); if (NULL == *QueryResultSet)
return NULL != (*QueryResultSet)->pName ? ERROR_SUCCESS : {
ERROR_OUTOFMEMORY; adns_finish( astate );
} return ERROR_OUTOFMEMORY;
if ( NULL == answer || adns_s_prohibitedcname != answer->status || }
NULL == answer->cname ) {
adns_finish( astate ); (*QueryResultSet)->pNext = NULL;
if ( CurrentName != Name ) { (*QueryResultSet)->wType = Type;
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName ); (*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA);
} (*QueryResultSet)->Data.A.IpAddress = answer->rrs.addr->addr.inet.sin_addr.s_addr;
return ERROR_FILE_NOT_FOUND;
} adns_finish(astate);
if ( CurrentName != Name ) {
RtlFreeHeap( RtlGetProcessHeap(), 0, CurrentName ); (*QueryResultSet)->pName = xstrsave( Name );
}
CurrentName = xstrsave( answer->cname ); return NULL != (*QueryResultSet)->pName ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
if ( NULL == CurrentName ) { }
adns_finish( astate );
return 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 ) { static PCHAR
int chars = wcstombs( NULL, WideString, 0 ); DnsWToC(const WCHAR *WideString)
PCHAR out = RtlAllocateHeap( RtlGetProcessHeap(), 0, chars + 1 ); {
wcstombs( out, WideString, chars + 1 ); int chars = wcstombs(NULL, WideString, 0);
return out; PCHAR out = RtlAllocateHeap(RtlGetProcessHeap(), 0, chars + 1);
wcstombs(out, WideString, chars + 1);
return out;
} }
static PWCHAR DnsCToW( const CHAR *NarrowString ) { static PWCHAR
int chars = mbstowcs( NULL, NarrowString, 0 ); DnsCToW(const CHAR *NarrowString)
PWCHAR out = RtlAllocateHeap( RtlGetProcessHeap(), 0, {
(chars + 1) * sizeof(WCHAR) ); int chars = mbstowcs(NULL, NarrowString, 0);
mbstowcs( out, NarrowString, chars + 1 ); PWCHAR out = RtlAllocateHeap(RtlGetProcessHeap(), 0, (chars + 1) * sizeof(WCHAR));
return out;
mbstowcs(out, NarrowString, chars + 1);
return out;
} }
DNS_STATUS WINAPI DnsQuery_W DNS_STATUS WINAPI
( LPCWSTR Name, DnsQuery_W(LPCWSTR Name,
WORD Type, WORD Type,
DWORD Options, DWORD Options,
PIP4_ARRAY Servers, PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet, PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) { PVOID *Reserved)
UINT i; {
PCHAR Buffer; UINT i;
DNS_STATUS Status; PCHAR Buffer;
PDNS_RECORD QueryResultWide; DNS_STATUS Status;
PDNS_RECORD ConvertedRecord = 0, LastRecord = 0; PDNS_RECORD QueryResultWide;
PDNS_RECORD ConvertedRecord = 0, LastRecord = 0;
Buffer = DnsWToC( Name ); Buffer = DnsWToC(Name);
Status = DnsQuery_A( Buffer, Type, Options, Servers, &QueryResultWide, Status = DnsQuery_A(Buffer, Type, Options, Servers, &QueryResultWide, Reserved);
Reserved );
while( Status == ERROR_SUCCESS && QueryResultWide ) { while(Status == ERROR_SUCCESS && QueryResultWide)
switch( QueryResultWide->wType ) { {
case DNS_TYPE_A: switch(QueryResultWide->wType)
case DNS_TYPE_WKS: {
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0, case DNS_TYPE_A:
sizeof(DNS_RECORD) ); case DNS_TYPE_WKS:
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName ); ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
ConvertedRecord->wType = QueryResultWide->wType; ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->wDataLength = QueryResultWide->wDataLength; ConvertedRecord->wType = QueryResultWide->wType;
memcpy( ConvertedRecord, QueryResultWide, ConvertedRecord->wDataLength = QueryResultWide->wDataLength;
QueryResultWide->wDataLength ); memcpy(ConvertedRecord, QueryResultWide, QueryResultWide->wDataLength);
break; break;
case DNS_TYPE_CNAME: case DNS_TYPE_CNAME:
case DNS_TYPE_PTR: case DNS_TYPE_PTR:
case DNS_TYPE_NS: case DNS_TYPE_NS:
case DNS_TYPE_MB: case DNS_TYPE_MB:
case DNS_TYPE_MD: case DNS_TYPE_MD:
case DNS_TYPE_MF: case DNS_TYPE_MF:
case DNS_TYPE_MG: case DNS_TYPE_MG:
case DNS_TYPE_MR: case DNS_TYPE_MR:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0, ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
sizeof(DNS_RECORD) ); ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName ); ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wType = QueryResultWide->wType; ConvertedRecord->wDataLength = sizeof(DNS_PTR_DATA);
ConvertedRecord->wDataLength = sizeof(DNS_PTR_DATA); ConvertedRecord->Data.PTR.pNameHost = (PCHAR)DnsCToW(QueryResultWide->Data.PTR.pNameHost);
ConvertedRecord->Data.PTR.pNameHost = break;
(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_MX: case DNS_TYPE_MINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0, ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
sizeof(DNS_RECORD) ); ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName ); ConvertedRecord->wType = QueryResultWide->wType;
ConvertedRecord->wType = QueryResultWide->wType; ConvertedRecord->wDataLength = sizeof(DNS_MINFO_DATA);
ConvertedRecord->wDataLength = sizeof(DNS_MX_DATA); ConvertedRecord->Data.MINFO.pNameMailbox = (PCHAR)DnsCToW(QueryResultWide->Data.MINFO.pNameMailbox);
ConvertedRecord->Data.MX.pNameExchange = ConvertedRecord->Data.MINFO.pNameErrorsMailbox = (PCHAR)DnsCToW(QueryResultWide->Data.MINFO.pNameErrorsMailbox);
(PCHAR)DnsCToW( QueryResultWide->Data.MX.pNameExchange ); break;
ConvertedRecord->Data.MX.wPreference =
QueryResultWide->Data.MX.wPreference;
break;
case DNS_TYPE_HINFO: case DNS_TYPE_MX:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0, ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
sizeof(DNS_TXT_DATA) + ConvertedRecord->pName = (PCHAR)DnsCToW(QueryResultWide->pName);
QueryResultWide-> ConvertedRecord->wType = QueryResultWide->wType;
Data.TXT.dwStringCount ); ConvertedRecord->wDataLength = sizeof(DNS_MX_DATA);
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName ); ConvertedRecord->Data.MX.pNameExchange = (PCHAR)DnsCToW( QueryResultWide->Data.MX.pNameExchange);
ConvertedRecord->wType = QueryResultWide->wType; ConvertedRecord->Data.MX.wPreference = QueryResultWide->Data.MX.wPreference;
ConvertedRecord->wDataLength = break;
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: case DNS_TYPE_HINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0, ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_TXT_DATA) + QueryResultWide->Data.TXT.dwStringCount);
sizeof(DNS_NULL_DATA) + ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName );
QueryResultWide-> ConvertedRecord->wType = QueryResultWide->wType;
Data.Null.dwByteCount ); ConvertedRecord->wDataLength = sizeof(DNS_TXT_DATA) + (sizeof(PWCHAR) * QueryResultWide->Data.TXT.dwStringCount);
ConvertedRecord->pName = (PCHAR)DnsCToW( QueryResultWide->pName ); ConvertedRecord->Data.TXT.dwStringCount = QueryResultWide->Data.TXT.dwStringCount;
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;
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 = 0;
LastRecord->pNext = ConvertedRecord;
LastRecord = LastRecord->pNext; /* The name */
} else { RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
LastRecord = *QueryResultSet = ConvertedRecord;
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" #include "adns.h"
typedef struct { typedef struct
adns_state State; {
adns_state State;
} WINDNS_CONTEXT, *PWINDNS_CONTEXT; } WINDNS_CONTEXT, *PWINDNS_CONTEXT;
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS( int Status ); DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS(int Status);
void DnsIntFreeRecordList( PDNS_RECORD ToFree ); void DnsIntFreeRecordList(PDNS_RECORD ToFree);
#endif//WINDNS_INTERNAL_H #endif//WINDNS_INTERNAL_H