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