source3/libaddns/dnsresponse.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 int32 DNSStdAllocateResponse( DNS_RESPONSE ** ppDNSResponse )
  33 {
  34         int32 dwError = 0;
  35         DNS_RESPONSE *pDNSResponse = NULL;
  36
  37         dwError =
  38                 DNSAllocateMemory( sizeof( DNS_RESPONSE ),
  39                                    ( void * ) &pDNSResponse );
  40         BAIL_ON_ERROR( dwError );
  41
  42         *ppDNSResponse = pDNSResponse;
  43
  44         return dwError;
  45
  46       error:
  47
  48         *ppDNSResponse = NULL;
  49
  50         return dwError;
  51 }
  52
  53 /*********************************************************************
  54 *********************************************************************/
  55
  56 static int32 DNSStdUnmarshallQuestionSection( HANDLE hReceiveBuffer,
  57                                  int16 wQuestions,
  58                                  DNS_QUESTION_RECORD *
  59                                  **pppDNSQuestionRecords )
  60 {
  61         int32 dwError = 0;
  62         int32 i = 0;
  63         int32 dwRead = 0;
  64         DNS_QUESTION_RECORD *pDNSQuestionRecord = NULL;
  65         DNS_QUESTION_RECORD **ppDNSQuestionRecords = NULL;
  66         int16 wnQueryClass = 0;
  67         int16 wnQueryType = 0;
  68
  69
  70         dwError =
  71                 DNSAllocateMemory( wQuestions *
  72                                    sizeof( DNS_QUESTION_RECORD * ),
  73                                    ( void * ) &ppDNSQuestionRecords );
  74         BAIL_ON_ERROR( dwError );
  75
  76         for ( i = 0; i < wQuestions; i++ ) {
  77
  78                 dwError =
  79                         DNSAllocateMemory( sizeof( DNS_QUESTION_RECORD ),
  80                                            ( void * ) &pDNSQuestionRecord );
  81                 BAIL_ON_ERROR( dwError );
  82
  83                 dwError =
  84                         DNSUnmarshallDomainName( hReceiveBuffer,
  85                                                  &pDNSQuestionRecord->
  86                                                  pDomainName );
  87                 BAIL_ON_ERROR( dwError );
  88
  89                 dwError =
  90                         DNSUnmarshallBuffer( hReceiveBuffer,
  91                                              ( uint8 * ) & wnQueryType,
  92                                              ( int32 ) sizeof( int16 ),
  93                                              &dwRead );
  94                 BAIL_ON_ERROR( dwError );
  95                 pDNSQuestionRecord->wQueryType = ntohs( wnQueryType );
  96
  97                 dwError =
  98                         DNSUnmarshallBuffer( hReceiveBuffer,
  99                                              ( uint8 * ) & wnQueryClass,
 100                                              ( int32 ) sizeof( int16 ),
 101                                              &dwRead );
 102                 BAIL_ON_ERROR( dwError );
 103                 pDNSQuestionRecord->wQueryClass = ntohs( wnQueryClass );
 104
 105                 *( ppDNSQuestionRecords + i ) = pDNSQuestionRecord;
 106         }
 107
 108         *pppDNSQuestionRecords = ppDNSQuestionRecords;
 109         return dwError;
 110
 111       error:
 112
 113         return dwError;
 114 }
 115
 116 /*********************************************************************
 117 *********************************************************************/
 118
 119 static int32 DNSStdUnmarshallAnswerSection( HANDLE hReceiveBuffer,
 120                                int16 wAnswers,
 121                                DNS_RR_RECORD * **pppDNSAnswerRRRecords )
 122 {
 123         int32 dwError = 0;
 124         int32 i = 0;
 125         DNS_RR_RECORD *pDNSRRRecord = NULL;
 126         DNS_RR_RECORD **ppDNSAnswerRRRecords = NULL;
 127         DNS_RR_HEADER RRHeader = { 0 };
 128         DNS_RR_HEADER *pRRHeader = &RRHeader;
 129         uint8 *pRData = NULL;
 130         int32 dwRead = 0;
 131
 132         dwError = DNSAllocateMemory( wAnswers * sizeof( DNS_RR_RECORD * ),
 133                                      ( void * ) &ppDNSAnswerRRRecords );
 134         BAIL_ON_ERROR( dwError );
 135
 136         for ( i = 0; i < wAnswers; i++ ) {
 137
 138                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
 139                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
 140                 BAIL_ON_ERROR( dwError );
 141
 142
 143                 dwError =
 144                         DNSUnmarshallRData( hReceiveBuffer,
 145                                             pRRHeader->wRDataSize, &pRData,
 146                                             &dwRead );
 147                 BAIL_ON_ERROR( dwError );
 148
 149                 dwError =
 150                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 151                                            ( void * ) &pDNSRRRecord );
 152                 BAIL_ON_ERROR( dwError );
 153
 154                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
 155                         sizeof( DNS_RR_HEADER ) );
 156                 pDNSRRRecord->pRData = pRData;
 157
 158                 *( ppDNSAnswerRRRecords + i ) = pDNSRRRecord;
 159         }
 160
 161         *pppDNSAnswerRRRecords = ppDNSAnswerRRRecords;
 162
 163         return dwError;
 164
 165       error:
 166
 167
 168         return dwError;
 169 }
 170
 171 /*********************************************************************
 172 *********************************************************************/
 173
 174 static int32 DNSStdUnmarshallAuthoritySection( HANDLE hReceiveBuffer,
 175                                   int16 wAuthoritys,
 176                                   DNS_RR_RECORD * **pppDNSAuthorityRRRecords )
 177 {
 178         int32 dwError = 0;
 179         int32 i = 0;
 180         DNS_RR_RECORD *pDNSRRRecord = NULL;
 181         DNS_RR_RECORD **ppDNSAuthorityRRRecords = NULL;
 182         DNS_RR_HEADER RRHeader = { 0 };
 183         DNS_RR_HEADER *pRRHeader = &RRHeader;
 184         uint8 *pRData = NULL;
 185         int32 dwRead = 0;
 186
 187         dwError = DNSAllocateMemory( wAuthoritys * sizeof( DNS_RR_RECORD * ),
 188                                      ( void * ) &ppDNSAuthorityRRRecords );
 189         BAIL_ON_ERROR( dwError );
 190
 191         for ( i = 0; i < wAuthoritys; i++ ) {
 192
 193                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
 194                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
 195                 BAIL_ON_ERROR( dwError );
 196
 197                 dwError =
 198                         DNSUnmarshallRData( hReceiveBuffer,
 199                                             pRRHeader->wRDataSize, &pRData,
 200                                             &dwRead );
 201                 BAIL_ON_ERROR( dwError );
 202
 203                 dwError =
 204                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 205                                            ( void * ) &pDNSRRRecord );
 206                 BAIL_ON_ERROR( dwError );
 207
 208                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
 209                         sizeof( DNS_RR_HEADER ) );
 210                 pDNSRRRecord->pRData = pRData;
 211
 212                 *( ppDNSAuthorityRRRecords + i ) = pDNSRRRecord;
 213         }
 214
 215         *pppDNSAuthorityRRRecords = ppDNSAuthorityRRRecords;
 216
 217         return dwError;
 218
 219       error:
 220
 221         return dwError;
 222
 223 }
 224
 225 /*********************************************************************
 226 *********************************************************************/
 227
 228 static int32 DNSStdUnmarshallAdditionalSection( HANDLE hReceiveBuffer,
 229                                                 int16 wAdditionals,
 230                                                 DNS_RR_RECORD *
 231                                                 **pppDNSAdditionalsRRRecords )
 232 {
 233         int32 dwError = 0;
 234         int32 i = 0;
 235         DNS_RR_RECORD *pDNSRRRecord = NULL;
 236         DNS_RR_RECORD **ppDNSAdditionalRRRecords = NULL;
 237         DNS_RR_HEADER RRHeader = { 0 };
 238         DNS_RR_HEADER *pRRHeader = &RRHeader;
 239         uint8 *pRData = NULL;
 240         int32 dwRead = 0;
 241
 242         dwError = DNSAllocateMemory( wAdditionals * sizeof( DNS_RR_RECORD * ),
 243                                      ( void * ) &ppDNSAdditionalRRRecords );
 244         BAIL_ON_ERROR( dwError );
 245
 246         for ( i = 0; i < wAdditionals; i++ ) {
 247
 248                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
 249                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
 250                 BAIL_ON_ERROR( dwError );
 251
 252                 dwError =
 253                         DNSUnmarshallRData( hReceiveBuffer,
 254                                             pRRHeader->wRDataSize, &pRData,
 255                                             &dwRead );
 256                 BAIL_ON_ERROR( dwError );
 257
 258                 dwError =
 259                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 260                                            ( void * ) &pDNSRRRecord );
 261                 BAIL_ON_ERROR( dwError );
 262
 263                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
 264                         sizeof( DNS_RR_HEADER ) );
 265                 pDNSRRRecord->pRData = pRData;
 266
 267
 268                 *( ppDNSAdditionalRRRecords + i ) = pDNSRRRecord;
 269         }
 270
 271       error:
 272
 273         return dwError;
 274 }
 275
 276 /*********************************************************************
 277 *********************************************************************/
 278
 279 int32 DNSStdReceiveStdResponse( HANDLE hDNSHandle, DNS_RESPONSE ** ppDNSResponse )
 280 {
 281         DNS_RESPONSE *pDNSResponse = NULL;
 282         int32 dwError = 0;
 283         int16 wnIdentification, wIdentification = 0;
 284         int16 wnParameter, wParameter = 0;
 285         int16 wnQuestions, wQuestions = 0;
 286         int16 wnAnswers, wAnswers = 0;
 287         int16 wnAdditionals, wAdditionals = 0;
 288         int16 wnAuthoritys, wAuthoritys = 0;
 289         int32 dwRead = 0;
 290         DNS_RR_RECORD **ppDNSAnswerRecords = NULL;
 291         DNS_RR_RECORD **ppDNSAdditionalRecords = NULL;
 292         DNS_RR_RECORD **ppDNSAuthorityRecords = NULL;
 293         DNS_QUESTION_RECORD **ppDNSQuestionRecords = NULL;
 294         HANDLE hRecvBuffer = ( HANDLE ) NULL;
 295
 296         dwError = DNSCreateReceiveBuffer( &hRecvBuffer );
 297         BAIL_ON_ERROR( dwError );
 298
 299         dwError = DNSReceiveBufferContext( hDNSHandle, hRecvBuffer, &dwRead );
 300         BAIL_ON_ERROR( dwError );
 301
 302 #if 0
 303         dwError = DNSDumpRecvBufferContext( hRecvBuffer );
 304         BAIL_ON_ERROR( dwError );
 305 #endif
 306
 307         dwError =
 308                 DNSUnmarshallBuffer( hRecvBuffer,
 309                                      ( uint8 * ) & wnIdentification,
 310                                      sizeof( int16 ), &dwRead );
 311         BAIL_ON_ERROR( dwError );
 312         wIdentification = ntohs( wnIdentification );
 313
 314         dwError =
 315                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnParameter,
 316                                      sizeof( int16 ), &dwRead );
 317         BAIL_ON_ERROR( dwError );
 318         wParameter = ntohs( wnParameter );
 319
 320
 321         dwError =
 322                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnQuestions,
 323                                      sizeof( int16 ), &dwRead );
 324         BAIL_ON_ERROR( dwError );
 325         wQuestions = ntohs( wnQuestions );
 326
 327
 328         dwError =
 329                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnAnswers,
 330                                      sizeof( int16 ), &dwRead );
 331         BAIL_ON_ERROR( dwError );
 332         wAnswers = ntohs( wnAnswers );
 333
 334
 335         dwError =
 336                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnAuthoritys,
 337                                      sizeof( int16 ), &dwRead );
 338         BAIL_ON_ERROR( dwError );
 339         wAuthoritys = ntohs( wnAuthoritys );
 340
 341         dwError =
 342                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnAdditionals,
 343                                      sizeof( int16 ), &dwRead );
 344         BAIL_ON_ERROR( dwError );
 345         wAdditionals = ntohs( wnAdditionals );
 346
 347
 348         if ( wQuestions ) {
 349                 dwError =
 350                         DNSStdUnmarshallQuestionSection( hRecvBuffer,
 351                                                          wQuestions,
 352                                                          &ppDNSQuestionRecords );
 353                 BAIL_ON_ERROR( dwError );
 354         }
 355
 356         if ( wAnswers ) {
 357                 dwError =
 358                         DNSStdUnmarshallAnswerSection( hRecvBuffer, wAnswers,
 359                                                        &ppDNSAnswerRecords );
 360                 BAIL_ON_ERROR( dwError );
 361         }
 362
 363         if ( wAuthoritys ) {
 364                 dwError =
 365                         DNSStdUnmarshallAuthoritySection( hRecvBuffer,
 366                                                           wAuthoritys,
 367                                                           &ppDNSAuthorityRecords );
 368                 BAIL_ON_ERROR( dwError );
 369         }
 370
 371         if ( wAdditionals ) {
 372                 dwError =
 373                         DNSStdUnmarshallAdditionalSection( hRecvBuffer,
 374                                                            wAdditionals,
 375                                                            &ppDNSAdditionalRecords );
 376                 BAIL_ON_ERROR( dwError );
 377         }
 378
 379         dwError = DNSStdAllocateResponse( &pDNSResponse );
 380         BAIL_ON_ERROR( dwError );
 381
 382         pDNSResponse->wIdentification = wIdentification;
 383         pDNSResponse->wParameter = wParameter;
 384         pDNSResponse->wQuestions = wQuestions;
 385         pDNSResponse->wAnswers = wAnswers;
 386         pDNSResponse->wAuthoritys = wAuthoritys;
 387         pDNSResponse->wAdditionals = wAdditionals;
 388
 389         pDNSResponse->ppQuestionRRSet = ppDNSQuestionRecords;
 390         pDNSResponse->ppAnswerRRSet = ppDNSAnswerRecords;
 391         pDNSResponse->ppAuthorityRRSet = ppDNSAuthorityRecords;
 392         pDNSResponse->ppAdditionalRRSet = ppDNSAdditionalRecords;
 393
 394         *ppDNSResponse = pDNSResponse;
 395
 396
 397       error:
 398
 399         return dwError;
 400 }
 401
 402 /*********************************************************************
 403 *********************************************************************/
 404
 405 int32 DNSUnmarshallDomainName( HANDLE hRecvBuffer, DNS_DOMAIN_NAME ** ppDomainName )
 406 {
 407         int32 dwError = 0;
 408         DNS_DOMAIN_LABEL *pLabel = NULL;
 409         DNS_DOMAIN_LABEL *pLabelList = NULL;
 410         DNS_DOMAIN_NAME *pDomainName = NULL;
 411         char *pszLabel = NULL;
 412         char szLabel[65];
 413         uint8 uLen = 0;
 414         int32 dwRead = 0;
 415         uint8 uLen1, uLen2 = 0;
 416         int16 wnOffset, wOffset = 0;
 417
 418         dwError =
 419                 DNSUnmarshallBuffer( hRecvBuffer, &uLen1, sizeof( char ),
 420                                      &dwRead );
 421         BAIL_ON_ERROR( dwError );
 422         if ( uLen1 & 0xC0 ) {
 423
 424                 uLen1 |= 0x3F;
 425                 dwError =
 426                         DNSUnmarshallBuffer( hRecvBuffer, &uLen2,
 427                                              sizeof( char ), &dwRead );
 428                 BAIL_ON_ERROR( dwError );
 429
 430                 memcpy( ( uint8 * ) & wnOffset, &uLen1, sizeof( char ) );
 431                 memcpy( ( uint8 * ) & wnOffset + 1, &uLen2, sizeof( char ) );
 432                 wOffset = ntohs( wnOffset );
 433
 434                 dwError =
 435                         DNSUnmarshallDomainNameAtOffset( hRecvBuffer, wOffset,
 436                                                          &pDomainName );
 437                 BAIL_ON_ERROR( dwError );
 438                 *ppDomainName = pDomainName;
 439
 440                 return dwError;
 441
 442         } else {
 443
 444                 dwError = DNSReceiveBufferMoveBackIndex( hRecvBuffer, 1 );
 445                 BAIL_ON_ERROR( dwError );
 446
 447                 while ( 1 ) {
 448
 449
 450                         dwError =
 451                                 DNSUnmarshallBuffer( hRecvBuffer, &uLen,
 452                                                      sizeof( char ),
 453                                                      &dwRead );
 454                         BAIL_ON_ERROR( dwError );
 455                         if ( uLen == 0 ) {
 456                                 break;
 457                         }
 458
 459                         memset( szLabel, 0, 65 );
 460                         dwError =
 461                                 DNSUnmarshallBuffer( hRecvBuffer,
 462                                                      ( uint8 * ) szLabel,
 463                                                      uLen, &dwRead );
 464
 465                         dwError = DNSAllocateString( szLabel, &pszLabel );
 466                         BAIL_ON_ERROR( dwError );
 467
 468                         dwError =
 469                                 DNSAllocateMemory( sizeof( DNS_DOMAIN_LABEL ),
 470                                                    ( void * ) &pLabel );
 471                         BAIL_ON_ERROR( dwError );
 472
 473                         pLabel->pszLabel = pszLabel;
 474                         dwError =
 475                                 DNSAppendLabel( pLabelList, pLabel,
 476                                                 &pLabelList );
 477                         BAIL_ON_ERROR( dwError );
 478                 }
 479
 480         }
 481
 482         dwError =
 483                 DNSAllocateMemory( sizeof( DNS_DOMAIN_NAME ),
 484                                    ( void * ) &pDomainName );
 485         BAIL_ON_ERROR( dwError );
 486         pDomainName->pLabelList = pLabelList;
 487
 488         *ppDomainName = pDomainName;
 489
 490         return dwError;
 491
 492       error:
 493
 494         *ppDomainName = NULL;
 495         return dwError;
 496 }
 497
 498 /*********************************************************************
 499 *********************************************************************/
 500
 501 int32 DNSUnmarshallRRHeader( HANDLE hRecvBuffer, DNS_RR_HEADER * pRRHeader )
 502 {
 503         int32 dwError = 0;
 504         int32 dwRead = 0;
 505         int16 wnType = 0;
 506         int16 wnClass = 0;
 507         int16 wnRDataSize = 0;
 508         int32 dwnTTL = 0;
 509
 510         dwError =
 511                 DNSUnmarshallDomainName( hRecvBuffer,
 512                                          &pRRHeader->pDomainName );
 513         BAIL_ON_ERROR( dwError );
 514
 515
 516         dwError =
 517                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnType,
 518                                      sizeof( int16 ), &dwRead );
 519         BAIL_ON_ERROR( dwError );
 520         pRRHeader->wType = ntohs( wnType );
 521
 522
 523         dwError =
 524                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnClass,
 525                                      sizeof( int16 ), &dwRead );
 526         BAIL_ON_ERROR( dwError );
 527         pRRHeader->wClass = ntohs( wnClass );
 528
 529         dwError =
 530                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & dwnTTL,
 531                                      sizeof( int32 ), &dwRead );
 532         BAIL_ON_ERROR( dwError );
 533         pRRHeader->dwTTL = ntohl( dwnTTL );
 534
 535         dwError =
 536                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnRDataSize,
 537                                      sizeof( int16 ), &dwRead );
 538         BAIL_ON_ERROR( dwError );
 539         pRRHeader->wRDataSize = htons( wnRDataSize );
 540
 541       error:
 542
 543         return dwError;
 544 }
 545
 546 /*********************************************************************
 547 *********************************************************************/
 548
 549 int32 DNSUnmarshallRData( HANDLE hRecvBuffer,
 550                     int32 dwSize, uint8 ** ppRData, int32 * pdwRead )
 551 {
 552         int32 dwError = 0;
 553         uint8 *pMemory = NULL;
 554
 555         dwError = DNSAllocateMemory( dwSize, ( void * ) &pMemory );
 556         BAIL_ON_ERROR( dwError );
 557         dwError =
 558                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) pMemory, dwSize,
 559                                      pdwRead );
 560         BAIL_ON_ERROR( dwError );
 561
 562         *ppRData = pMemory;
 563
 564         return dwError;
 565
 566       error:
 567
 568         if ( pMemory ) {
 569                 DNSFreeMemory( pMemory );
 570         }
 571
 572         *ppRData = NULL;
 573         return dwError;
 574 }
 575
 576 /*********************************************************************
 577 *********************************************************************/
 578
 579 int32 DNSUpdateGetResponseCode( DNS_UPDATE_RESPONSE * pDNSUpdateResponse,
 580                           int32 * pdwResponseCode )
 581 {
 582         int32 dwError = 0;
 583
 584         *pdwResponseCode =
 585                 MapDNSResponseCodes( pDNSUpdateResponse->wParameter );
 586
 587         return dwError;
 588 }
 589