diff --git a/reactos/dll/win32/dnsapi/dnsapi/adns.c b/reactos/dll/win32/dnsapi/dnsapi/adns.c
index de9029b781c..e0cf7f8f31f 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/adns.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/adns.c
@@ -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;
+    }
+}
diff --git a/reactos/dll/win32/dnsapi/dnsapi/context.c b/reactos/dll/win32/dnsapi/dnsapi/context.c
index 95ef7c61f77..dd83ba57b7b 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/context.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/context.c
@@ -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);
 }
-
-
diff --git a/reactos/dll/win32/dnsapi/dnsapi/free.c b/reactos/dll/win32/dnsapi/dnsapi/free.c
index a700f43532b..27ac7ddcea7 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/free.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/free.c
@@ -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);
 }
diff --git a/reactos/dll/win32/dnsapi/dnsapi/names.c b/reactos/dll/win32/dnsapi/dnsapi/names.c
index a1c4eea4400..6959305e8f5 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/names.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/names.c
@@ -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);
 }
-
diff --git a/reactos/dll/win32/dnsapi/dnsapi/query.c b/reactos/dll/win32/dnsapi/dnsapi/query.c
index 6d559fd364e..62d25fcfd15 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/query.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/query.c
@@ -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;
-  }
 }
diff --git a/reactos/dll/win32/dnsapi/dnsapi/stubs.c b/reactos/dll/win32/dnsapi/dnsapi/stubs.c
index 798f506be3f..792af2acaa8 100644
--- a/reactos/dll/win32/dnsapi/dnsapi/stubs.c
+++ b/reactos/dll/win32/dnsapi/dnsapi/stubs.c
@@ -8,577 +8,807 @@
 
 typedef ULONG DNS_STATUS;
 
-DNS_STATUS WINAPI DnsAddRecordSet_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAddRecordSet_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAddRecordSet_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAddRecordSet_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAddRecordSet_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAddRecordSet_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAllocateRecord() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAllocateRecord()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsApiHeapReset() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsApiHeapReset()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAsyncRegisterHostAddrs_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAsyncRegisterHostAddrs_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAsyncRegisterHostAddrs_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAsyncRegisterHostAddrs_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAsyncRegisterInit() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAsyncRegisterInit()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsAsyncRegisterTerm() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsAsyncRegisterTerm()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCheckNameCollision_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCheckNameCollision_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCheckNameCollision_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCheckNameCollision_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCheckNameCollision_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCheckNameCollision_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCopyStringEx() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCopyStringEx()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCreateReverseNameStringForIpAddress() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCreateReverseNameStringForIpAddress()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCreateStandardDnsNameCopy() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCreateStandardDnsNameCopy()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsCreateStringCopy() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsCreateStringCopy()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDhcpSrvRegisterHostName_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDhcpSrvRegisterHostName_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDhcpSrvRegisterInit() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDhcpSrvRegisterInit()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDhcpSrvRegisterTerm() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDhcpSrvRegisterTerm()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDisableAdapterDomainNameRegistration() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDisableAdapterDomainNameRegistration()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDisableBNodeResolverThread() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDisableBNodeResolverThread()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDisableDynamicRegistration() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDisableDynamicRegistration()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsDowncaseDnsNameLabel() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsDowncaseDnsNameLabel()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsEnableAdapterDomainNameRegistration() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsEnableAdapterDomainNameRegistration()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsEnableBNodeResolverThread() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsEnableBNodeResolverThread()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsEnableDynamicRegistration() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsEnableDynamicRegistration()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsExtractRecordsFromMessage_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsExtractRecordsFromMessage_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsExtractRecordsFromMessage_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsExtractRecordsFromMessage_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFindAuthoritativeZone() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFindAuthoritativeZone()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFlushResolverCache() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFlushResolverCache()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFlushResolverCacheEntry_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFlushResolverCacheEntry_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFlushResolverCacheEntry_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFlushResolverCacheEntry_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFlushResolverCacheEntry_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFlushResolverCacheEntry_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFreeAdapterInformation() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFreeAdapterInformation()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFreeNetworkInformation() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFreeNetworkInformation()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsFreeSearchInformation() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsFreeSearchInformation()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetBufferLengthForStringCopy() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetBufferLengthForStringCopy()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetCacheDataTable() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetCacheDataTable()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetDnsServerList() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetDnsServerList()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetDomainName() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetDomainName()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetHostName_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetHostName_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetHostName_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetHostName_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetHostName_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetHostName_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetIpAddressInfoList() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetIpAddressInfoList()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetIpAddressList() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetIpAddressList()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetLastServerUpdateIP() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetLastServerUpdateIP()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetMaxNumberOfAddressesToRegister() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetMaxNumberOfAddressesToRegister()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetNetworkInformation() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetNetworkInformation()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetPrimaryDomainName_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetPrimaryDomainName_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetPrimaryDomainName_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetPrimaryDomainName_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetPrimaryDomainName_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetPrimaryDomainName_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsGetSearchInformation() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsGetSearchInformation()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIpv6AddressToString() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIpv6AddressToString()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIpv6StringToAddress() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIpv6StringToAddress()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIsAMailboxType() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIsAMailboxType()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIsAdapterDomainNameRegistrationEnabled() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIsAdapterDomainNameRegistrationEnabled()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIsDynamicRegistrationEnabled() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIsDynamicRegistrationEnabled()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIsStatusRcode() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIsStatusRcode()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsIsStringCountValidForTextType() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsIsStringCountValidForTextType()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsMapRcodeToStatus() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsMapRcodeToStatus()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordSet_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordSet_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordSet_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordSet_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordSet_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordSet_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordsInSet_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordsInSet_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordsInSet_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordsInSet_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsModifyRecordsInSet_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsModifyRecordsInSet_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsNameCompareEx_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsNameCompareEx_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsNameCompareEx_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsNameCompareEx_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsNameCompareEx_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsNameCompareEx_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsNameCopy() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsNameCopy()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsNameCopyAllocate() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsNameCopyAllocate()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsQueryConfig() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsQueryConfig()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsQueryEx() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsQueryEx()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordBuild_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordBuild_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordBuild_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordBuild_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordCompare() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordCompare()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordCopyEx() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordCopyEx()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordSetCompare() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordSetCompare()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordSetCopyEx() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordSetCopyEx()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordSetDetach() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordSetDetach()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordStringForType() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordStringForType()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordStringForWritableType() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordStringForWritableType()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRecordTypeForName() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRecordTypeForName()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRelationalCompare_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRelationalCompare_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRelationalCompare_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRelationalCompare_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsRemoveRegistrations() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsRemoveRegistrations()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSetA() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSetA()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSetUTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSetUTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSetW() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSetW()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSet_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSet_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSet_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSet_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsReplaceRecordSet_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsReplaceRecordSet_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationDeregister_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationDeregister_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationDeregister_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationDeregister_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationDeregister_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationDeregister_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationRegister_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationRegister_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationRegister_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationRegister_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsServiceNotificationRegister_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsServiceNotificationRegister_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsSetMaxNumberOfAddressesToRegister() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsSetMaxNumberOfAddressesToRegister()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsStatusString() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsStatusString()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsStringCopyAllocateEx() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsStringCopyAllocateEx()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUnicodeToUtf8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUnicodeToUtf8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUpdate() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUpdate()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUpdateTest_A() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUpdateTest_A()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUpdateTest_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUpdateTest_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUpdateTest_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUpdateTest_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsUtf8ToUnicode() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsUtf8ToUnicode()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsValidateUtf8Byte() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsValidateUtf8Byte()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsWinsRecordFlagForString() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsWinsRecordFlagForString()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsWinsRecordFlagString() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsWinsRecordFlagString()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsWriteQuestionToBuffer_UTF8() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsWriteQuestionToBuffer_UTF8()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsWriteQuestionToBuffer_W() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsWriteQuestionToBuffer_W()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI DnsWriteReverseNameStringForIpAddress() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+DnsWriteReverseNameStringForIpAddress()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
 
-DNS_STATUS WINAPI GetCurrentTimeInSeconds() {
-  UNIMPLEMENTED;
-  return ERROR_OUTOFMEMORY;
+DNS_STATUS WINAPI
+GetCurrentTimeInSeconds()
+{
+    UNIMPLEMENTED;
+    return ERROR_OUTOFMEMORY;
 }
diff --git a/reactos/dll/win32/dnsapi/include/internal/windns.h b/reactos/dll/win32/dnsapi/include/internal/windns.h
index 82346569ef9..569017f8739 100644
--- a/reactos/dll/win32/dnsapi/include/internal/windns.h
+++ b/reactos/dll/win32/dnsapi/include/internal/windns.h
@@ -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