Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-21 04:37:15 +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

9
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 ) {
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;
}
}

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

@ -30,66 +30,65 @@
* 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,
DNS_STATUS WINAPI
DnsAcquireContextHandle_W(DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle ) {
if( CredentialsFlags ) {
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 ) );
Context = (PWINDNS_CONTEXT)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WINDNS_CONTEXT));
if(!Context){
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 ) {
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 {
}
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,
DNS_STATUS WINAPI
DnsAcquireContextHandle_UTF8(DWORD CredentialsFlags,
PVOID Credentials,
HANDLE *ContextHandle ) {
if( CredentialsFlags ) {
return DnsAcquireContextHandle_W( CredentialsFlags,
Credentials,
ContextHandle );
} else {
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. */
@ -97,29 +96,29 @@ DNS_STATUS WINAPI DnsAcquireContextHandle_UTF8
}
}
DNS_STATUS WINAPI DnsAcquireContextHandle_A
( DWORD CredentialFlags,
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 );
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 ) {
void WINAPI
DnsReleaseContextHandle(HANDLE ContextHandle)
{
PWINDNS_CONTEXT Context = (PWINDNS_CONTEXT)ContextHandle;
adns_finish(Context->State);
RtlFreeHeap(RtlGetProcessHeap(), 0, Context);
}

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

@ -13,9 +13,12 @@
#define NDEBUG
#include <debug.h>
VOID WINAPI DnsFree
( PVOID Data, DNS_FREE_TYPE FreeType ) {
switch( FreeType ) {
VOID WINAPI
DnsFree(PVOID Data,
DNS_FREE_TYPE FreeType)
{
switch(FreeType)
{
case DnsFreeFlat:
RtlFreeHeap( RtlGetProcessHeap(), 0, Data );
break;
@ -30,7 +33,9 @@ VOID WINAPI DnsFree
}
}
VOID WINAPI DnsRecordListFree
( PDNS_RECORD Data, DNS_FREE_TYPE FreeType ) {
VOID WINAPI
DnsRecordListFree(PDNS_RECORD Data,
DNS_FREE_TYPE FreeType)
{
DnsFree(Data, FreeType);
}

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

@ -3,15 +3,21 @@
#define NDEBUG
#include <debug.h>
static BOOL DnsIntNameContainsDots( LPCWSTR Name ) {
static BOOL
DnsIntNameContainsDots(LPCWSTR Name)
{
return wcschr(Name, '.') ? TRUE : FALSE;
}
static BOOL DnsIntTwoConsecutiveDots( LPCWSTR Name ) {
static BOOL
DnsIntTwoConsecutiveDots(LPCWSTR Name)
{
return wcsstr(Name, L"..") ? TRUE : FALSE;
}
static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) {
static BOOL
DnsIntContainsUnderscore(LPCWSTR Name)
{
return wcschr(Name, '_') ? TRUE : FALSE;
}
@ -47,57 +53,67 @@ static BOOL DnsIntContainsUnderscore( LPCWSTR Name ) {
* If the name contains a non-ascii character.
*/
DNS_STATUS WINAPI DnsValidateName_W
( LPCWSTR Name,
DNS_NAME_FORMAT Format ) {
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 ) {
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;
}
/* Preliminary checks */
if( Name[0] == 0 ) return ERROR_INVALID_NAME; /* XXX arty: Check this */
if(Name[0] == 0)
return ERROR_INVALID_NAME; /* XXX arty: Check this */
/* Name too long */
if( wcslen( Name ) > 255 ) {
if(wcslen(Name) > 255)
return ERROR_INVALID_NAME;
}
/* Violations about dots */
if( (!AllowDot && DnsIntNameContainsDots( Name )) ||
Name[0] == '.' || DnsIntTwoConsecutiveDots( Name ) )
if((!AllowDot && DnsIntNameContainsDots(Name)) || Name[0] == '.' || DnsIntTwoConsecutiveDots(Name))
return ERROR_INVALID_NAME;
/* Check component sizes */
CurrentLabel = Name;
do {
do
{
NextLabel = CurrentLabel;
while( *NextLabel && *NextLabel != '.' ) NextLabel++;
while(*NextLabel && *NextLabel != '.')
NextLabel++;
if(NextLabel - CurrentLabel > 63)
return ERROR_INVALID_NAME;
@ -107,42 +123,44 @@ DNS_STATUS WINAPI DnsValidateName_W
CurrentChar = Name;
while( *CurrentChar ) {
while(*CurrentChar)
{
if(wcschr(L" {|}~[\\]^':;<=>?@!\"#$%^`()+/,",*CurrentChar))
return DNS_ERROR_INVALID_NAME_CHAR;
CurrentChar++;
}
if( (!AllowLeadingAst && Name[0] == '*') ||
(AllowLeadingAst && Name[0] == '*' && Name[1] && Name[1] != '.') )
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 ) {
while(!AllowAllDigits && *CurrentChar)
{
if(*CurrentChar == '.' || (*CurrentChar >= '0' && *CurrentChar <= '9'))
return DNS_ERROR_NUMERIC_NAME;
}
if( ((AllowLeadingUnderscore && Name[0] == '_') || Name[0] != '_') &&
!DnsIntContainsUnderscore( Name + 1 ) )
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 ) {
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) );
Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(WCHAR) * (StrLenWc + 1));
mbstowcs(Buffer, Name, StrLenWc + 1);
Status = DnsValidateName_W(Buffer, Format);
RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
@ -150,9 +168,10 @@ DNS_STATUS WINAPI DnsValidateName_UTF8
return Status;
}
DNS_STATUS WINAPI DnsValidateName_A
( LPCSTR Name,
DNS_NAME_FORMAT Format ) {
DNS_STATUS WINAPI
DnsValidateName_A(LPCSTR Name,
DNS_NAME_FORMAT Format)
{
return DnsValidateName_UTF8(Name, Format);
}
@ -161,36 +180,39 @@ DNS_STATUS WINAPI DnsValidateName_A
*
* Name1 & Name2 -- Names.
*/
BOOL WINAPI DnsNameCompare_W
( LPWSTR Name1,
LPWSTR Name2 ) {
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"."));
}
BOOL WINAPI DnsNameCompare_UTF8
( LPCSTR Name1,
LPCSTR Name2 ) {
BOOL WINAPI
DnsNameCompare_UTF8(LPCSTR Name1,
LPCSTR Name2)
{
int offset = 0;
while( Name1[offset] && Name2[offset] &&
toupper( Name1[offset] ) == toupper( Name2[offset] ) ) offset++;
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 ) {
BOOL WINAPI
DnsNameCompare_A(LPSTR Name1,
LPSTR Name2)
{
return DnsNameCompare_UTF8(Name1, Name2);
}

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

@ -31,23 +31,27 @@
* Reserved -- Response as it appears on the wire. Optional.
*/
char *xstrsave(const char *str) {
char
*xstrsave(const char *str)
{
char *p;
p = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(str) + 1);
if ( NULL != p ) {
if(p)
strcpy(p, str);
}
return p;
}
DNS_STATUS WINAPI DnsQuery_A
( LPCSTR Name,
DNS_STATUS WINAPI
DnsQuery_A(LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
PVOID *Reserved)
{
adns_state astate;
int quflags = 0, i;
int adns_error;
@ -57,21 +61,18 @@ DNS_STATUS WINAPI DnsQuery_A
*QueryResultSet = 0;
switch( Type ) {
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 );
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 ) {
if(adns_error != adns_s_ok)
return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
}
if (Servers) {
for( i = 0; i < Servers->AddrCount; i++ ) {
if (Servers)
{
for(i = 0; i < Servers->AddrCount; i++)
{
adns_addserver(astate, *((struct in_addr *)&Servers->AddrArray[i]));
}
}
@ -92,89 +93,107 @@ DNS_STATUS WINAPI DnsQuery_A
#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 );
if( adns_error != adns_s_ok ) {
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)
{
adns_finish(astate);
if ( CurrentName != Name ) {
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
}
return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
}
if( answer && answer->rrs.addr ) {
if ( CurrentName != Name ) {
if(answer && answer->rrs.addr)
{
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
}
*QueryResultSet =
(PDNS_RECORD)RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof( DNS_RECORD ) );
if ( NULL == *QueryResultSet ) {
*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;
(*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;
return NULL != (*QueryResultSet)->pName ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
}
if ( NULL == answer || adns_s_prohibitedcname != answer->status ||
NULL == answer->cname ) {
if (NULL == answer || adns_s_prohibitedcname != answer->status || NULL == answer->cname)
{
adns_finish(astate);
if ( CurrentName != Name ) {
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
}
return ERROR_FILE_NOT_FOUND;
}
if ( CurrentName != Name ) {
if (CurrentName != Name)
RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
}
CurrentName = xstrsave(answer->cname);
if ( NULL == CurrentName ) {
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. */
}
}
static PCHAR DnsWToC( const WCHAR *WideString ) {
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 ) {
static PWCHAR
DnsCToW(const CHAR *NarrowString)
{
int chars = mbstowcs(NULL, NarrowString, 0);
PWCHAR out = RtlAllocateHeap( RtlGetProcessHeap(), 0,
(chars + 1) * sizeof(WCHAR) );
PWCHAR out = RtlAllocateHeap(RtlGetProcessHeap(), 0, (chars + 1) * sizeof(WCHAR));
mbstowcs(out, NarrowString, chars + 1);
return out;
}
DNS_STATUS WINAPI DnsQuery_W
( LPCWSTR Name,
DNS_STATUS WINAPI
DnsQuery_W(LPCWSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
PVOID *Reserved)
{
UINT i;
PCHAR Buffer;
DNS_STATUS Status;
@ -183,20 +202,19 @@ DNS_STATUS WINAPI DnsQuery_W
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 ) {
while(Status == ERROR_SUCCESS && QueryResultWide)
{
switch(QueryResultWide->wType)
{
case DNS_TYPE_A:
case DNS_TYPE_WKS:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
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 );
memcpy(ConvertedRecord, QueryResultWide, QueryResultWide->wDataLength);
break;
case DNS_TYPE_CNAME:
@ -207,78 +225,60 @@ DNS_STATUS WINAPI DnsQuery_W
case DNS_TYPE_MF:
case DNS_TYPE_MG:
case DNS_TYPE_MR:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
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 );
ConvertedRecord->Data.PTR.pNameHost = (PCHAR)DnsCToW(QueryResultWide->Data.PTR.pNameHost);
break;
case DNS_TYPE_MINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
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 );
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:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_RECORD) );
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;
ConvertedRecord->Data.MX.pNameExchange = (PCHAR)DnsCToW( QueryResultWide->Data.MX.pNameExchange);
ConvertedRecord->Data.MX.wPreference = QueryResultWide->Data.MX.wPreference;
break;
case DNS_TYPE_HINFO:
ConvertedRecord = RtlAllocateHeap( RtlGetProcessHeap(), 0,
sizeof(DNS_TXT_DATA) +
QueryResultWide->
Data.TXT.dwStringCount );
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] );
}
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 = 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 );
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 ) {
if(LastRecord)
{
LastRecord->pNext = ConvertedRecord;
LastRecord = LastRecord->pNext;
} else {
}
else
{
LastRecord = *QueryResultSet = ConvertedRecord;
}
}
@ -291,25 +291,31 @@ DNS_STATUS WINAPI DnsQuery_W
return Status;
}
DNS_STATUS WINAPI DnsQuery_UTF8
( LPCSTR Name,
DNS_STATUS WINAPI
DnsQuery_UTF8(LPCSTR Name,
WORD Type,
DWORD Options,
PIP4_ARRAY Servers,
PDNS_RECORD *QueryResultSet,
PVOID *Reserved ) {
PVOID *Reserved)
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
void DnsIntFreeRecordList( PDNS_RECORD ToDelete ) {
void
DnsIntFreeRecordList(PDNS_RECORD ToDelete)
{
UINT i;
PDNS_RECORD next = 0;
while( ToDelete ) {
while(ToDelete)
{
if(ToDelete->pName)
RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->pName);
switch( ToDelete->wType ) {
switch(ToDelete->wType)
{
case DNS_TYPE_CNAME:
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
@ -320,19 +326,18 @@ void DnsIntFreeRecordList( PDNS_RECORD ToDelete ) {
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] );
}
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;

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

@ -8,577 +8,807 @@
typedef ULONG DNS_STATUS;
DNS_STATUS WINAPI DnsAddRecordSet_A() {
DNS_STATUS WINAPI
DnsAddRecordSet_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAddRecordSet_UTF8() {
DNS_STATUS WINAPI
DnsAddRecordSet_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAddRecordSet_W() {
DNS_STATUS WINAPI
DnsAddRecordSet_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAllocateRecord() {
DNS_STATUS WINAPI
DnsAllocateRecord()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsApiHeapReset() {
DNS_STATUS WINAPI
DnsApiHeapReset()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_A() {
DNS_STATUS WINAPI
DnsAsyncRegisterHostAddrs_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_UTF8() {
DNS_STATUS WINAPI
DnsAsyncRegisterHostAddrs_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_W() {
DNS_STATUS WINAPI
DnsAsyncRegisterHostAddrs_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAsyncRegisterInit() {
DNS_STATUS WINAPI
DnsAsyncRegisterInit()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsAsyncRegisterTerm() {
DNS_STATUS WINAPI
DnsAsyncRegisterTerm()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCheckNameCollision_A() {
DNS_STATUS WINAPI
DnsCheckNameCollision_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCheckNameCollision_UTF8() {
DNS_STATUS WINAPI
DnsCheckNameCollision_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCheckNameCollision_W() {
DNS_STATUS WINAPI
DnsCheckNameCollision_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCopyStringEx() {
DNS_STATUS WINAPI
DnsCopyStringEx()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCreateReverseNameStringForIpAddress() {
DNS_STATUS WINAPI
DnsCreateReverseNameStringForIpAddress()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCreateStandardDnsNameCopy() {
DNS_STATUS WINAPI
DnsCreateStandardDnsNameCopy()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsCreateStringCopy() {
DNS_STATUS WINAPI
DnsCreateStringCopy()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDhcpSrvRegisterHostName_W() {
DNS_STATUS WINAPI
DnsDhcpSrvRegisterHostName_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDhcpSrvRegisterInit() {
DNS_STATUS WINAPI
DnsDhcpSrvRegisterInit()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDhcpSrvRegisterTerm() {
DNS_STATUS WINAPI
DnsDhcpSrvRegisterTerm()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDisableAdapterDomainNameRegistration() {
DNS_STATUS WINAPI
DnsDisableAdapterDomainNameRegistration()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDisableBNodeResolverThread() {
DNS_STATUS WINAPI
DnsDisableBNodeResolverThread()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDisableDynamicRegistration() {
DNS_STATUS WINAPI
DnsDisableDynamicRegistration()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsDowncaseDnsNameLabel() {
DNS_STATUS WINAPI
DnsDowncaseDnsNameLabel()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsEnableAdapterDomainNameRegistration() {
DNS_STATUS WINAPI
DnsEnableAdapterDomainNameRegistration()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsEnableBNodeResolverThread() {
DNS_STATUS WINAPI
DnsEnableBNodeResolverThread()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsEnableDynamicRegistration() {
DNS_STATUS WINAPI
DnsEnableDynamicRegistration()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsExtractRecordsFromMessage_UTF8() {
DNS_STATUS WINAPI
DnsExtractRecordsFromMessage_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsExtractRecordsFromMessage_W() {
DNS_STATUS WINAPI
DnsExtractRecordsFromMessage_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFindAuthoritativeZone() {
DNS_STATUS WINAPI
DnsFindAuthoritativeZone()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFlushResolverCache() {
DNS_STATUS WINAPI
DnsFlushResolverCache()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFlushResolverCacheEntry_A() {
DNS_STATUS WINAPI
DnsFlushResolverCacheEntry_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFlushResolverCacheEntry_UTF8() {
DNS_STATUS WINAPI
DnsFlushResolverCacheEntry_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFlushResolverCacheEntry_W() {
DNS_STATUS WINAPI
DnsFlushResolverCacheEntry_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFreeAdapterInformation() {
DNS_STATUS WINAPI
DnsFreeAdapterInformation()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFreeNetworkInformation() {
DNS_STATUS WINAPI
DnsFreeNetworkInformation()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsFreeSearchInformation() {
DNS_STATUS WINAPI
DnsFreeSearchInformation()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetBufferLengthForStringCopy() {
DNS_STATUS WINAPI
DnsGetBufferLengthForStringCopy()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetCacheDataTable() {
DNS_STATUS WINAPI
DnsGetCacheDataTable()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetDnsServerList() {
DNS_STATUS WINAPI
DnsGetDnsServerList()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetDomainName() {
DNS_STATUS WINAPI
DnsGetDomainName()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetHostName_A() {
DNS_STATUS WINAPI
DnsGetHostName_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetHostName_UTF8() {
DNS_STATUS WINAPI
DnsGetHostName_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetHostName_W() {
DNS_STATUS WINAPI
DnsGetHostName_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetIpAddressInfoList() {
DNS_STATUS WINAPI
DnsGetIpAddressInfoList()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetIpAddressList() {
DNS_STATUS WINAPI
DnsGetIpAddressList()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetLastServerUpdateIP() {
DNS_STATUS WINAPI
DnsGetLastServerUpdateIP()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetMaxNumberOfAddressesToRegister() {
DNS_STATUS WINAPI
DnsGetMaxNumberOfAddressesToRegister()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetNetworkInformation() {
DNS_STATUS WINAPI
DnsGetNetworkInformation()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetPrimaryDomainName_A() {
DNS_STATUS WINAPI
DnsGetPrimaryDomainName_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetPrimaryDomainName_UTF8() {
DNS_STATUS WINAPI
DnsGetPrimaryDomainName_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetPrimaryDomainName_W() {
DNS_STATUS WINAPI
DnsGetPrimaryDomainName_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsGetSearchInformation() {
DNS_STATUS WINAPI
DnsGetSearchInformation()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIpv6AddressToString() {
DNS_STATUS WINAPI
DnsIpv6AddressToString()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIpv6StringToAddress() {
DNS_STATUS WINAPI
DnsIpv6StringToAddress()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIsAMailboxType() {
DNS_STATUS WINAPI
DnsIsAMailboxType()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIsAdapterDomainNameRegistrationEnabled() {
DNS_STATUS WINAPI
DnsIsAdapterDomainNameRegistrationEnabled()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIsDynamicRegistrationEnabled() {
DNS_STATUS WINAPI
DnsIsDynamicRegistrationEnabled()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIsStatusRcode() {
DNS_STATUS WINAPI
DnsIsStatusRcode()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsIsStringCountValidForTextType() {
DNS_STATUS WINAPI
DnsIsStringCountValidForTextType()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsMapRcodeToStatus() {
DNS_STATUS WINAPI
DnsMapRcodeToStatus()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordSet_A() {
DNS_STATUS WINAPI
DnsModifyRecordSet_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordSet_UTF8() {
DNS_STATUS WINAPI
DnsModifyRecordSet_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordSet_W() {
DNS_STATUS WINAPI
DnsModifyRecordSet_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordsInSet_A() {
DNS_STATUS WINAPI
DnsModifyRecordsInSet_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordsInSet_UTF8() {
DNS_STATUS WINAPI
DnsModifyRecordsInSet_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsModifyRecordsInSet_W() {
DNS_STATUS WINAPI
DnsModifyRecordsInSet_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsNameCompareEx_A() {
DNS_STATUS WINAPI
DnsNameCompareEx_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsNameCompareEx_UTF8() {
DNS_STATUS WINAPI
DnsNameCompareEx_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsNameCompareEx_W() {
DNS_STATUS WINAPI
DnsNameCompareEx_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsNameCopy() {
DNS_STATUS WINAPI
DnsNameCopy()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsNameCopyAllocate() {
DNS_STATUS WINAPI
DnsNameCopyAllocate()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsQueryConfig() {
DNS_STATUS WINAPI
DnsQueryConfig()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsQueryEx() {
DNS_STATUS WINAPI
DnsQueryEx()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordBuild_UTF8() {
DNS_STATUS WINAPI
DnsRecordBuild_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordBuild_W() {
DNS_STATUS WINAPI
DnsRecordBuild_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordCompare() {
DNS_STATUS WINAPI
DnsRecordCompare()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordCopyEx() {
DNS_STATUS WINAPI
DnsRecordCopyEx()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordSetCompare() {
DNS_STATUS WINAPI
DnsRecordSetCompare()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordSetCopyEx() {
DNS_STATUS WINAPI
DnsRecordSetCopyEx()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordSetDetach() {
DNS_STATUS WINAPI
DnsRecordSetDetach()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordStringForType() {
DNS_STATUS WINAPI
DnsRecordStringForType()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordStringForWritableType() {
DNS_STATUS WINAPI
DnsRecordStringForWritableType()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRecordTypeForName() {
DNS_STATUS WINAPI
DnsRecordTypeForName()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRelationalCompare_UTF8() {
DNS_STATUS WINAPI
DnsRelationalCompare_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRelationalCompare_W() {
DNS_STATUS WINAPI
DnsRelationalCompare_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsRemoveRegistrations() {
DNS_STATUS WINAPI
DnsRemoveRegistrations()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSetA() {
DNS_STATUS WINAPI
DnsReplaceRecordSetA()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSetUTF8() {
DNS_STATUS WINAPI
DnsReplaceRecordSetUTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSetW() {
DNS_STATUS WINAPI
DnsReplaceRecordSetW()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSet_A() {
DNS_STATUS WINAPI
DnsReplaceRecordSet_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSet_UTF8() {
DNS_STATUS WINAPI
DnsReplaceRecordSet_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsReplaceRecordSet_W() {
DNS_STATUS WINAPI
DnsReplaceRecordSet_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationDeregister_A() {
DNS_STATUS WINAPI
DnsServiceNotificationDeregister_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationDeregister_UTF8() {
DNS_STATUS WINAPI
DnsServiceNotificationDeregister_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationDeregister_W() {
DNS_STATUS WINAPI
DnsServiceNotificationDeregister_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationRegister_A() {
DNS_STATUS WINAPI
DnsServiceNotificationRegister_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationRegister_UTF8() {
DNS_STATUS WINAPI
DnsServiceNotificationRegister_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsServiceNotificationRegister_W() {
DNS_STATUS WINAPI
DnsServiceNotificationRegister_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsSetMaxNumberOfAddressesToRegister() {
DNS_STATUS WINAPI
DnsSetMaxNumberOfAddressesToRegister()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsStatusString() {
DNS_STATUS WINAPI
DnsStatusString()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsStringCopyAllocateEx() {
DNS_STATUS WINAPI
DnsStringCopyAllocateEx()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUnicodeToUtf8() {
DNS_STATUS WINAPI
DnsUnicodeToUtf8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUpdate() {
DNS_STATUS WINAPI
DnsUpdate()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUpdateTest_A() {
DNS_STATUS WINAPI
DnsUpdateTest_A()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUpdateTest_UTF8() {
DNS_STATUS WINAPI
DnsUpdateTest_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUpdateTest_W() {
DNS_STATUS WINAPI
DnsUpdateTest_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsUtf8ToUnicode() {
DNS_STATUS WINAPI
DnsUtf8ToUnicode()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsValidateUtf8Byte() {
DNS_STATUS WINAPI
DnsValidateUtf8Byte()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsWinsRecordFlagForString() {
DNS_STATUS WINAPI
DnsWinsRecordFlagForString()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsWinsRecordFlagString() {
DNS_STATUS WINAPI
DnsWinsRecordFlagString()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsWriteQuestionToBuffer_UTF8() {
DNS_STATUS WINAPI
DnsWriteQuestionToBuffer_UTF8()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsWriteQuestionToBuffer_W() {
DNS_STATUS WINAPI
DnsWriteQuestionToBuffer_W()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI DnsWriteReverseNameStringForIpAddress() {
DNS_STATUS WINAPI
DnsWriteReverseNameStringForIpAddress()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}
DNS_STATUS WINAPI GetCurrentTimeInSeconds() {
DNS_STATUS WINAPI
GetCurrentTimeInSeconds()
{
UNIMPLEMENTED;
return ERROR_OUTOFMEMORY;
}

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

@ -3,7 +3,8 @@
#include "adns.h"
typedef struct {
typedef struct
{
adns_state State;
} WINDNS_CONTEXT, *PWINDNS_CONTEXT;