source3/libaddns/dnssock.c

   1 /*
   2   Linux DNS client library implementation
   3
   4   Copyright (C) 2006 Krishna Ganugapati <krishnag@centeris.com>
   5   Copyright (C) 2006 Gerald Carter <jerry@samba.org>
   6
   7      ** NOTE! The following LGPL license applies to the libaddns
   8      ** library. This does NOT imply that all of Samba is released
   9      ** under the LGPL
  10
  11   This library is free software; you can redistribute it and/or
  12   modify it under the terms of the GNU Lesser General Public
  13   License as published by the Free Software Foundation; either
  14   version 2.1 of the License, or (at your option) any later version.
  15
  16   This library is distributed in the hope that it will be useful,
  17   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19   Lesser General Public License for more details.
  20
  21   You should have received a copy of the GNU Lesser General Public
  22   License along with this library; if not, write to the Free Software
  23   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  24   02110-1301  USA
  25 */
  26
  27 #include "dns.h"
  28 #include <sys/time.h>
  29
  30 /********************************************************************
  31 ********************************************************************/
  32
  33 static DNS_ERROR DNSTCPOpen( char *nameserver, HANDLE * phDNSServer )
  34 {
  35         DNS_ERROR dwError = ERROR_DNS_INVALID_PARAMETER;
  36         int sockServer;
  37         unsigned long ulAddress;
  38         struct hostent *pHost;
  39         struct sockaddr_in s_in;
  40         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
  41
  42         if ( (pDNSContext = TALLOC_P( NULL, DNS_CONNECTION_CONTEXT )) == NULL ) {
  43                 return ERROR_DNS_NO_MEMORY;
  44         }
  45
  46         if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
  47                 if ( (pHost = gethostbyname( nameserver )) == NULL ) {
  48                         dwError = ERROR_DNS_INVALID_NAME_SERVER;
  49                         BAIL_ON_DNS_ERROR( dwError );
  50                 }
  51                 memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
  52         }
  53
  54         if ( (sockServer = socket( PF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET ) {
  55                 dwError = ERROR_DNS_NO_MEMORY;
  56                 BAIL_ON_DNS_ERROR( dwError );
  57         }
  58
  59         s_in.sin_family = AF_INET;
  60         s_in.sin_addr.s_addr = ulAddress;
  61         s_in.sin_port = htons( DNS_TCP_PORT );
  62
  63         if ( (connect( sockServer, (struct sockaddr*)&s_in, sizeof( s_in ))) == SOCKET_ERROR ) {
  64                 dwError = ERROR_DNS_CONNECTION_FAILED;
  65                 BAIL_ON_DNS_ERROR( dwError );
  66         }
  67
  68         pDNSContext->s = sockServer;
  69         pDNSContext->hType = DNS_TCP;
  70
  71         *phDNSServer = ( HANDLE ) pDNSContext;
  72
  73         dwError = ERROR_DNS_SUCCESS;
  74
  75         return dwError;
  76
  77 error:
  78         TALLOC_FREE( pDNSContext );
  79         *phDNSServer = ( HANDLE ) NULL;
  80
  81         return dwError;
  82 }
  83
  84 /********************************************************************
  85 ********************************************************************/
  86
  87 static DNS_ERROR DNSUDPOpen( char *nameserver, HANDLE * phDNSServer )
  88 {
  89         DNS_ERROR dwError = ERROR_DNS_INVALID_PARAMETER;
  90         int SendSocket;
  91         unsigned long ulAddress;
  92         struct hostent *pHost;
  93         struct sockaddr_in RecvAddr;
  94         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
  95
  96         if ( (pDNSContext = TALLOC_P( NULL, DNS_CONNECTION_CONTEXT )) == NULL ) {
  97                 return ERROR_DNS_NO_MEMORY;
  98         }
  99
 100         if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
 101                 if ( (pHost = gethostbyname( nameserver )) == NULL ) {
 102                         dwError = ERROR_DNS_INVALID_NAME_SERVER;
 103                         BAIL_ON_DNS_ERROR( dwError );
 104                 }
 105                 memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
 106         }
 107
 108         /* Create a socket for sending data */
 109
 110         SendSocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
 111
 112         /* Set up the RecvAddr structure with the IP address of
 113            the receiver (in this example case "123.456.789.1")
 114            and the specified port number. */
 115
 116         RecvAddr.sin_family = AF_INET;
 117         RecvAddr.sin_port = htons( DNS_UDP_PORT );
 118         RecvAddr.sin_addr.s_addr = ulAddress;
 119
 120         pDNSContext->s = SendSocket;
 121         pDNSContext->hType = DNS_UDP;
 122         memcpy( &pDNSContext->RecvAddr, &RecvAddr, sizeof( struct sockaddr_in ) );
 123
 124         *phDNSServer = ( HANDLE ) pDNSContext;
 125
 126         dwError = ERROR_DNS_SUCCESS;
 127
 128         return dwError;
 129
 130 error:
 131         TALLOC_FREE( pDNSContext );
 132         *phDNSServer = ( HANDLE ) NULL;
 133
 134         return dwError;
 135 }
 136
 137 /********************************************************************
 138 ********************************************************************/
 139
 140 DNS_ERROR DNSOpen( char *nameserver, int32 dwType, HANDLE * phDNSServer )
 141 {
 142         switch ( dwType ) {
 143         case DNS_TCP:
 144                 return DNSTCPOpen( nameserver, phDNSServer );
 145         case DNS_UDP:
 146                 return DNSUDPOpen( nameserver, phDNSServer );
 147         }
 148
 149         return ERROR_DNS_INVALID_PARAMETER;
 150 }
 151
 152 /********************************************************************
 153 ********************************************************************/
 154
 155 static int32 DNSSendTCPRequest( HANDLE hDNSHandle,
 156                    uint8 * pDNSSendBuffer,
 157                    int32 dwBufferSize, int32 * pdwBytesSent )
 158 {
 159         int32 dwError = 0;
 160         int32 dwBytesSent = 0;
 161         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 162
 163
 164         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 165
 166         dwBytesSent = send( pDNSContext->s, pDNSSendBuffer, dwBufferSize, 0 );
 167         if ( dwBytesSent == SOCKET_ERROR ) {
 168                 dwError = WSAGetLastError(  );
 169                 BAIL_ON_ERROR( dwError );
 170         }
 171
 172         *pdwBytesSent = dwBytesSent;
 173
 174         return dwError;
 175
 176       error:
 177         *pdwBytesSent = 0;
 178         return dwError;
 179 }
 180
 181 /********************************************************************
 182 ********************************************************************/
 183
 184 static int32 DNSSendUDPRequest( HANDLE hDNSHandle,
 185                    uint8 * pDNSSendBuffer,
 186                    int32 dwBufferSize, int32 * pdwBytesSent )
 187 {
 188         int32 dwError = 0;
 189         int32 dwBytesSent = 0;
 190         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 191
 192         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 193
 194         dwBytesSent = sendto( pDNSContext->s,
 195                               pDNSSendBuffer,
 196                               dwBufferSize,
 197                               0,
 198                               ( struct sockaddr * ) & pDNSContext->RecvAddr,
 199                               sizeof( pDNSContext->RecvAddr )
 200                  );
 201         if ( dwBytesSent == SOCKET_ERROR ) {
 202                 dwError = WSAGetLastError(  );
 203                 BAIL_ON_ERROR( dwError );
 204         } else {
 205                 *pdwBytesSent = dwBytesSent;
 206         }
 207
 208         return dwError;
 209
 210       error:
 211         *pdwBytesSent = 0;
 212         return dwError;
 213 }
 214
 215 /********************************************************************
 216 ********************************************************************/
 217
 218 static int32 DNSSelect( HANDLE hDNSHandle )
 219 {
 220         int32 dwError = 0;
 221         fd_set rfds;
 222         struct timeval tv;
 223         int32 dwNumSockets = 0;
 224         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 225
 226         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 227         FD_ZERO( &rfds );
 228         FD_SET( pDNSContext->s, &rfds );
 229
 230         tv.tv_sec = 10;
 231         tv.tv_usec = 0;
 232         dwNumSockets = select( pDNSContext->s + 1, &rfds, NULL, NULL, &tv );
 233         if ( dwNumSockets == SOCKET_ERROR ) {
 234                 dwError = WSAGetLastError(  );
 235                 BAIL_ON_ERROR( dwError );
 236         }
 237
 238         if ( !dwNumSockets ) {
 239 #ifndef WIN32
 240                 dwError = ETIMEDOUT;
 241 #else
 242                 dwError = WSAETIMEDOUT;
 243 #endif
 244         }
 245
 246       error:
 247
 248         return dwError;
 249 }
 250
 251 /********************************************************************
 252 ********************************************************************/
 253
 254 static int32 DNSTCPReceiveBufferContext( HANDLE hDNSHandle,
 255                             HANDLE hDNSRecvBuffer, int32 * pdwBytesRead )
 256 {
 257         int32 dwError = 0;
 258         int32 dwRead = 0;
 259         int16 wBytesToRead = 0;
 260         int16 wnBytesToRead = 0;
 261         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 262         DNS_RECEIVEBUFFER_CONTEXT *pDNSRecvContext = NULL;
 263
 264         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 265         pDNSRecvContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hDNSRecvBuffer;
 266
 267         dwError = DNSSelect( hDNSHandle );
 268         BAIL_ON_ERROR( dwError );
 269
 270         dwRead = recv( pDNSContext->s, ( char * ) &wnBytesToRead,
 271                        sizeof( int16 ), 0 );
 272         if ( dwRead == SOCKET_ERROR ) {
 273                 dwError = WSAGetLastError(  );
 274                 BAIL_ON_ERROR( dwError );
 275         }
 276
 277         wBytesToRead = ntohs( wnBytesToRead );
 278
 279         dwError = DNSSelect( hDNSHandle );
 280         BAIL_ON_ERROR( dwError );
 281
 282         dwRead = recv( pDNSContext->s,
 283                        ( char * ) pDNSRecvContext->pRecvBuffer, wBytesToRead,
 284                        0 );
 285         if ( dwRead == SOCKET_ERROR ) {
 286                 dwError = WSAGetLastError(  );
 287                 BAIL_ON_ERROR( dwError );
 288         }
 289
 290         pDNSRecvContext->dwBytesRecvd = dwRead;
 291
 292         *pdwBytesRead = ( int32 ) dwRead;
 293
 294         return dwError;
 295
 296       error:
 297
 298         return dwError;
 299 }
 300
 301 /********************************************************************
 302 ********************************************************************/
 303
 304 static int32 DNSUDPReceiveBufferContext( HANDLE hDNSHandle,
 305                             HANDLE hDNSRecvBuffer, int32 * pdwBytesRead )
 306 {
 307         int32 dwError = 0;
 308         int32 dwRead = 0;
 309         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 310         DNS_RECEIVEBUFFER_CONTEXT *pDNSRecvContext = NULL;
 311
 312         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 313         pDNSRecvContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hDNSRecvBuffer;
 314
 315         dwError = DNSSelect( hDNSHandle );
 316         BAIL_ON_ERROR( dwError );
 317
 318         dwRead = recv( pDNSContext->s,
 319                        ( char * ) pDNSRecvContext->pRecvBuffer, 512, 0 );
 320         if ( dwRead == SOCKET_ERROR ) {
 321                 dwError = WSAGetLastError(  );
 322                 BAIL_ON_ERROR( dwError );
 323         }
 324
 325         pDNSRecvContext->dwBytesRecvd = dwRead;
 326
 327         *pdwBytesRead = ( int32 ) dwRead;
 328
 329       error:
 330
 331         return dwError;
 332 }
 333
 334 /********************************************************************
 335 ********************************************************************/
 336
 337 int32 DNSReceiveBufferContext( HANDLE hDNSHandle,
 338                          HANDLE hDNSRecvBuffer, int32 * pdwBytesRead )
 339 {
 340         int32 dwError = 0;
 341         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 342
 343         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSHandle;
 344
 345         switch ( pDNSContext->hType ) {
 346         case DNS_TCP:
 347                 dwError =
 348                         DNSTCPReceiveBufferContext( hDNSHandle,
 349                                                     hDNSRecvBuffer,
 350                                                     pdwBytesRead );
 351                 break;
 352         case DNS_UDP:
 353                 dwError =
 354                         DNSUDPReceiveBufferContext( hDNSHandle,
 355                                                     hDNSRecvBuffer,
 356                                                     pdwBytesRead );
 357                 break;
 358         }
 359         return dwError;
 360 }
 361
 362 /********************************************************************
 363 ********************************************************************/
 364
 365 int32 DNSCreateSendBuffer( HANDLE * phDNSSendBuffer )
 366 {
 367         int32 dwError = 0;
 368         DNS_SENDBUFFER_CONTEXT *pDNSContext = NULL;
 369         uint8 *pSendBuffer = NULL;
 370
 371         dwError = DNSAllocateMemory( sizeof( DNS_SENDBUFFER_CONTEXT ),
 372                                      ( void * ) &pDNSContext );
 373         BAIL_ON_ERROR( dwError );
 374
 375         dwError =
 376                 DNSAllocateMemory( SENDBUFFER_SIZE,
 377                                    ( void * ) &pSendBuffer );
 378         BAIL_ON_ERROR( dwError );
 379
 380         pDNSContext->pSendBuffer = pSendBuffer;
 381         pDNSContext->dwBufferSize = SENDBUFFER_SIZE;
 382
 383         /* We will offset into the buffer by 2 bytes
 384            If we are doing a TCP write; we will fill in these
 385            two bytes and send + 2 bytes
 386            If we are doing a UDP write; we will start our send
 387            +2 bytes and only send dwWritten; */
 388
 389         pDNSContext->dwBufferOffset += 2;
 390
 391         *phDNSSendBuffer = ( HANDLE ) pDNSContext;
 392
 393         return dwError;
 394
 395       error:
 396
 397         if ( pSendBuffer ) {
 398                 DNSFreeMemory( pSendBuffer );
 399         }
 400         if ( pDNSContext ) {
 401                 DNSFreeMemory( pDNSContext );
 402         }
 403         *phDNSSendBuffer = ( HANDLE ) NULL;
 404
 405         return dwError;
 406 }
 407
 408
 409 /********************************************************************
 410 ********************************************************************/
 411
 412 int32 DNSMarshallBuffer( HANDLE hDNSSendBuffer,
 413                    uint8 * pDNSSendBuffer,
 414                    int32 dwBufferSize, int32 * pdwBytesWritten )
 415 {
 416         int32 dwError = 0;
 417         uint8 *pTemp = NULL;
 418         DNS_SENDBUFFER_CONTEXT *pDNSContext = NULL;
 419
 420 /* BugBug - we need to check for amount of space remaining in the
 421 SendBuffer Context - if its insufficent, we want to realloc the
 422 Buffer and copy the context; Right now the assumption is we have a big
 423 enough buffer */
 424
 425         pDNSContext = ( DNS_SENDBUFFER_CONTEXT * ) hDNSSendBuffer;
 426
 427         pTemp = pDNSContext->pSendBuffer + pDNSContext->dwBufferOffset;
 428
 429         memcpy( pTemp, pDNSSendBuffer, dwBufferSize );
 430
 431         pDNSContext->dwBytesWritten += dwBufferSize;
 432         pDNSContext->dwBufferOffset += dwBufferSize;
 433
 434         *pdwBytesWritten = dwBufferSize;
 435
 436         return dwError;
 437 }
 438
 439 /********************************************************************
 440 ********************************************************************/
 441
 442 static int32 DNSTCPSendBufferContext( HANDLE hDNSServer,
 443                          HANDLE hSendBuffer, int32 * pdwBytesSent )
 444 {
 445         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 446         int32 dwError = 0;
 447         int16 wBytesWritten = 0;
 448         int16 wnBytesWritten = 0;
 449
 450         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 451
 452         wBytesWritten = ( int16 ) pSendBufferContext->dwBytesWritten;
 453         wnBytesWritten = htons( wBytesWritten );
 454
 455         memcpy( pSendBufferContext->pSendBuffer, &wnBytesWritten,
 456                 sizeof( int16 ) );
 457
 458         dwError = DNSSendTCPRequest( hDNSServer,
 459                                      pSendBufferContext->pSendBuffer,
 460                                      pSendBufferContext->dwBytesWritten + 2,
 461                                      pdwBytesSent );
 462         BAIL_ON_ERROR( dwError );
 463
 464       error:
 465
 466         return dwError;
 467 }
 468
 469 /********************************************************************
 470 ********************************************************************/
 471
 472 static int32 DNSUDPSendBufferContext( HANDLE hDNSServer,
 473                          HANDLE hSendBuffer, int32 * pdwBytesSent )
 474 {
 475         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 476         int32 dwError = 0;
 477
 478         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 479
 480         /* Now remember to send 2 bytes ahead of pSendBuffer; because
 481            we ignore the 2 bytes size field. */
 482
 483         dwError = DNSSendUDPRequest( hDNSServer,
 484                                      pSendBufferContext->pSendBuffer + 2,
 485                                      pSendBufferContext->dwBytesWritten,
 486                                      pdwBytesSent );
 487         BAIL_ON_ERROR( dwError );
 488
 489       error:
 490
 491         return dwError;
 492 }
 493
 494 /********************************************************************
 495 ********************************************************************/
 496
 497 int32 DNSSendBufferContext( HANDLE hDNSServer,
 498                       HANDLE hSendBuffer, int32 * pdwBytesSent )
 499 {
 500         DNS_CONNECTION_CONTEXT *pDNSContext = NULL;
 501         int32 dwError = 0;
 502
 503         pDNSContext = ( DNS_CONNECTION_CONTEXT * ) hDNSServer;
 504
 505         switch ( pDNSContext->hType ) {
 506         case DNS_TCP:
 507                 dwError = DNSTCPSendBufferContext( hDNSServer,
 508                                                    hSendBuffer,
 509                                                    pdwBytesSent );
 510                 BAIL_ON_ERROR( dwError );
 511                 break;
 512
 513         case DNS_UDP:
 514                 dwError = DNSUDPSendBufferContext( hDNSServer,
 515                                                    hSendBuffer,
 516                                                    pdwBytesSent );
 517                 BAIL_ON_ERROR( dwError );
 518                 break;
 519         }
 520       error:
 521
 522         return dwError;
 523 }
 524
 525 /********************************************************************
 526 ********************************************************************/
 527
 528 int32 DNSDumpSendBufferContext( HANDLE hSendBuffer )
 529 {
 530         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 531         int32 dwError = 0;
 532         int32 dwCurLine = 0;
 533         int32 i = 0;
 534
 535         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 536         printf( "\n" );
 537         printf( "Buffer Size is: %d\n", pSendBufferContext->dwBytesWritten );
 538         while ( i < pSendBufferContext->dwBytesWritten ) {
 539                 if ( ( i / 16 ) > dwCurLine ) {
 540                         printf( "\n" );
 541                         dwCurLine++;
 542                 }
 543                 if ( ( i % 8 ) == 0 ) {
 544                         printf( "  " );
 545                 }
 546                 printf( "%.2x ", pSendBufferContext->pSendBuffer[i] );
 547                 i++;
 548         }
 549         return dwError;
 550 }
 551
 552 /********************************************************************
 553 ********************************************************************/
 554
 555 int32 DNSDumpRecvBufferContext( HANDLE hRecvBuffer )
 556 {
 557         DNS_RECEIVEBUFFER_CONTEXT *pRecvBufferContext = NULL;
 558         int32 dwError = 0;
 559         int32 dwCurLine = 0;
 560         int32 i = 0;
 561
 562         pRecvBufferContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hRecvBuffer;
 563
 564         printf( "\n" );
 565         printf( "Buffer Size is: %d\n", pRecvBufferContext->dwBytesRecvd );
 566
 567         while ( i < pRecvBufferContext->dwBytesRecvd ) {
 568                 if ( ( i / 16 ) > dwCurLine ) {
 569                         printf( "\n" );
 570                         dwCurLine++;
 571                 }
 572                 if ( ( i % 8 ) == 0 ) {
 573                         printf( "  " );
 574                 }
 575                 printf( "%.2x ", pRecvBufferContext->pRecvBuffer[i] );
 576                 i++;
 577         }
 578         return dwError;
 579 }
 580
 581 /********************************************************************
 582 ********************************************************************/
 583
 584 int32 DNSCreateReceiveBuffer( HANDLE * phDNSRecvBuffer )
 585 {
 586         int32 dwError = 0;
 587         DNS_RECEIVEBUFFER_CONTEXT *pDNSContext = NULL;
 588         uint8 *pRecvBuffer = NULL;
 589
 590         dwError = DNSAllocateMemory( sizeof( DNS_RECEIVEBUFFER_CONTEXT ),
 591                                      ( void * ) &pDNSContext );
 592         BAIL_ON_ERROR( dwError );
 593
 594         dwError =
 595                 DNSAllocateMemory( RECVBUFFER_SIZE,
 596                                    ( void * ) &pRecvBuffer );
 597         BAIL_ON_ERROR( dwError );
 598
 599         pDNSContext->pRecvBuffer = pRecvBuffer;
 600         pDNSContext->dwBufferSize = RECVBUFFER_SIZE;
 601
 602         *phDNSRecvBuffer = ( HANDLE ) pDNSContext;
 603
 604         return dwError;
 605
 606       error:
 607
 608         if ( pRecvBuffer ) {
 609                 DNSFreeMemory( pRecvBuffer );
 610         }
 611         if ( pDNSContext ) {
 612                 DNSFreeMemory( pDNSContext );
 613         }
 614         *phDNSRecvBuffer = ( HANDLE ) NULL;
 615
 616         return dwError;
 617 }
 618
 619 /********************************************************************
 620 ********************************************************************/
 621
 622 int32 DNSUnmarshallBuffer( HANDLE hDNSRecvBuffer,
 623                      uint8 * pDNSRecvBuffer,
 624                      int32 dwBufferSize, int32 * pdwBytesRead )
 625 {
 626         int32 dwError = 0;
 627         uint8 *pTemp = NULL;
 628         DNS_RECEIVEBUFFER_CONTEXT *pDNSContext = NULL;
 629
 630 /* BugBug - we need to check for amount of space remaining in the
 631 SendBuffer Context - if its insufficent, we want to realloc the
 632 Buffer and copy the context; Right now the assumption is we have a big
 633 enough buffer */
 634
 635         pDNSContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hDNSRecvBuffer;
 636
 637         pTemp = pDNSContext->pRecvBuffer + pDNSContext->dwBytesRead;
 638
 639         memcpy( pDNSRecvBuffer, pTemp, dwBufferSize );
 640
 641         pDNSContext->dwBytesRead += dwBufferSize;
 642
 643         *pdwBytesRead = dwBufferSize;
 644
 645         return dwError;
 646 }
 647
 648 /********************************************************************
 649 ********************************************************************/
 650
 651 int32 DNSUnmarshallDomainNameAtOffset( HANDLE hRecvBuffer,
 652                                  int16 wOffset,
 653                                  DNS_DOMAIN_NAME ** ppDomainName )
 654 {
 655         int32 dwError = 0;
 656         DNS_DOMAIN_LABEL *pLabel = NULL;
 657         DNS_DOMAIN_LABEL *pLabelList = NULL;
 658         DNS_DOMAIN_NAME *pDomainName = NULL;
 659         char *pszLabel = NULL;
 660         char szLabel[65];
 661         uint8 uLen = 0;
 662         int32 dwCurrent = 0;
 663         DNS_RECEIVEBUFFER_CONTEXT *pRecvContext = NULL;
 664
 665         pRecvContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hRecvBuffer;
 666         dwCurrent = wOffset;
 667
 668         while ( 1 ) {
 669
 670                 memcpy( &uLen, pRecvContext->pRecvBuffer + dwCurrent,
 671                         sizeof( char ) );
 672                 dwCurrent++;
 673
 674                 if ( uLen == 0 ) {
 675                         break;
 676                 }
 677
 678                 memset( szLabel, 0, 65 );
 679                 memcpy( szLabel, pRecvContext->pRecvBuffer + dwCurrent,
 680                         uLen );
 681                 dwCurrent += uLen;
 682
 683                 dwError = DNSAllocateString( szLabel, &pszLabel );
 684                 BAIL_ON_ERROR( dwError );
 685
 686                 dwError =
 687                         DNSAllocateMemory( sizeof( DNS_DOMAIN_LABEL ),
 688                                            ( void * ) &pLabel );
 689                 BAIL_ON_ERROR( dwError );
 690
 691                 pLabel->pszLabel = pszLabel;
 692                 dwError = DNSAppendLabel( pLabelList, pLabel, &pLabelList );
 693                 BAIL_ON_ERROR( dwError );
 694         }
 695
 696         dwError =
 697                 DNSAllocateMemory( sizeof( DNS_DOMAIN_NAME ),
 698                                    ( void * ) &pDomainName );
 699         BAIL_ON_ERROR( dwError );
 700         pDomainName->pLabelList = pLabelList;
 701
 702         *ppDomainName = pDomainName;
 703
 704         return dwError;
 705
 706       error:
 707
 708         *ppDomainName = NULL;
 709         return dwError;
 710 }
 711
 712 /********************************************************************
 713 ********************************************************************/
 714
 715 int32 DNSReceiveBufferMoveBackIndex( HANDLE hRecvBuffer, int16 wOffset )
 716 {
 717         int32 dwError = 0;
 718         DNS_RECEIVEBUFFER_CONTEXT *pDNSContext = NULL;
 719
 720         pDNSContext = ( DNS_RECEIVEBUFFER_CONTEXT * ) hRecvBuffer;
 721         pDNSContext->dwBytesRead -= wOffset;
 722
 723         return dwError;
 724 }
 725
 726 /********************************************************************
 727 ********************************************************************/
 728
 729 void DNSFreeSendBufferContext( HANDLE hSendBuffer )
 730 {
 731         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 732
 733         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 734
 735         if ( pSendBufferContext && pSendBufferContext->pSendBuffer ) {
 736                 DNSFreeMemory( pSendBufferContext->pSendBuffer );
 737         }
 738         if ( pSendBufferContext ) {
 739                 DNSFreeMemory( pSendBufferContext );
 740         }
 741 }
 742
 743 /********************************************************************
 744 ********************************************************************/
 745
 746 int32 DNSGetSendBufferContextSize( HANDLE hSendBuffer )
 747 {
 748         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 749
 750         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 751
 752         return ( pSendBufferContext->dwBytesWritten );
 753
 754 }
 755
 756 /********************************************************************
 757 ********************************************************************/
 758
 759 uint8 *DNSGetSendBufferContextBuffer( HANDLE hSendBuffer )
 760 {
 761         DNS_SENDBUFFER_CONTEXT *pSendBufferContext = NULL;
 762
 763         pSendBufferContext = ( DNS_SENDBUFFER_CONTEXT * ) hSendBuffer;
 764
 765         return ( pSendBufferContext->pSendBuffer );
 766 }
 767