source/libaddns/dnsupresp.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 DNSUpdateAllocateResponse( DNS_UPDATE_RESPONSE ** ppDNSResponse )
  33 {
  34         int32 dwError = 0;
  35         DNS_UPDATE_RESPONSE *pDNSResponse = NULL;
  36
  37         dwError =
  38                 DNSAllocateMemory( sizeof( DNS_UPDATE_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 DNSUpdateUnmarshallAdditionalSection( HANDLE hReceiveBuffer,
  57                                       int16 wAdditionals,
  58                                       DNS_RR_RECORD *
  59                                       **pppDNSAdditionalsRRRecords )
  60 {
  61         int32 dwError = 0;
  62         int32 i = 0;
  63         DNS_RR_RECORD *pDNSRRRecord = NULL;
  64         DNS_RR_RECORD **ppDNSAdditionalRRRecords = NULL;
  65         DNS_RR_HEADER RRHeader = { 0 };
  66         DNS_RR_HEADER *pRRHeader = &RRHeader;
  67         uint8 *pRRData = NULL;
  68         int32 dwRead = 0;
  69
  70         dwError = DNSAllocateMemory( wAdditionals * sizeof( DNS_RR_RECORD * ),
  71                                      ( void * ) &ppDNSAdditionalRRRecords );
  72         BAIL_ON_ERROR( dwError );
  73
  74         for ( i = 0; i < wAdditionals; i++ ) {
  75
  76                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
  77                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
  78                 BAIL_ON_ERROR( dwError );
  79
  80                 dwError =
  81                         DNSUnmarshallRData( hReceiveBuffer,
  82                                             pRRHeader->wRDataSize, &pRRData,
  83                                             &dwRead );
  84                 BAIL_ON_ERROR( dwError );
  85
  86                 dwError =
  87                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
  88                                            ( void * ) &pDNSRRRecord );
  89                 BAIL_ON_ERROR( dwError );
  90
  91                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
  92                         sizeof( DNS_RR_HEADER ) );
  93                 pDNSRRRecord->pRData = pRRData;
  94
  95                 *( ppDNSAdditionalRRRecords + i ) = pDNSRRRecord;
  96         }
  97
  98       error:
  99
 100         return dwError;
 101 }
 102
 103 /*********************************************************************
 104 *********************************************************************/
 105
 106 static int32 DNSUpdateUnmarshallPRSection( HANDLE hReceiveBuffer,
 107                               int16 wPRs,
 108                               DNS_RR_RECORD * **pppDNSPRRRRecords )
 109 {
 110         int32 dwError = 0;
 111         int32 i = 0;
 112         DNS_RR_RECORD *pDNSRRRecord = NULL;
 113         DNS_RR_RECORD **ppDNSPRRRRecords = NULL;
 114         DNS_RR_HEADER RRHeader = { 0 };
 115         DNS_RR_HEADER *pRRHeader = &RRHeader;
 116         uint8 *pRRData = NULL;
 117         int32 dwRead = 0;
 118
 119         dwError = DNSAllocateMemory( wPRs * sizeof( DNS_RR_RECORD * ),
 120                                      ( void * ) &ppDNSPRRRRecords );
 121         BAIL_ON_ERROR( dwError );
 122
 123         for ( i = 0; i < wPRs; i++ ) {
 124
 125                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
 126                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
 127                 BAIL_ON_ERROR( dwError );
 128
 129                 dwError =
 130                         DNSUnmarshallRData( hReceiveBuffer,
 131                                             pRRHeader->wRDataSize, &pRRData,
 132                                             &dwRead );
 133                 BAIL_ON_ERROR( dwError );
 134
 135                 dwError =
 136                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 137                                            ( void * ) &pDNSRRRecord );
 138                 BAIL_ON_ERROR( dwError );
 139
 140                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
 141                         sizeof( DNS_RR_HEADER ) );
 142                 pDNSRRRecord->pRData = pRRData;
 143
 144                 *( ppDNSPRRRRecords + i ) = pDNSRRRecord;
 145         }
 146
 147         *pppDNSPRRRRecords = ppDNSPRRRRecords;
 148
 149         return dwError;
 150
 151       error:
 152
 153
 154         return dwError;
 155 }
 156
 157 /*********************************************************************
 158 *********************************************************************/
 159
 160 static int32 DNSUpdateUnmarshallUpdateSection( HANDLE hReceiveBuffer,
 161                                   int16 wUpdates,
 162                                   DNS_RR_RECORD * **pppDNSUpdateRRRecords )
 163 {
 164         int32 dwError = 0;
 165         int32 i = 0;
 166         DNS_RR_RECORD *pDNSRRRecord = NULL;
 167         DNS_RR_RECORD **ppDNSUpdateRRRecords = NULL;
 168         DNS_RR_HEADER RRHeader = { 0 };
 169         DNS_RR_HEADER *pRRHeader = &RRHeader;
 170         uint8 *pRRData = NULL;
 171         int32 dwRead = 0;
 172
 173         dwError = DNSAllocateMemory( wUpdates * sizeof( DNS_RR_RECORD * ),
 174                                      ( void * ) &ppDNSUpdateRRRecords );
 175         BAIL_ON_ERROR( dwError );
 176
 177         for ( i = 0; i < wUpdates; i++ ) {
 178
 179                 memset( pRRHeader, 0, sizeof( DNS_RR_HEADER ) );
 180                 dwError = DNSUnmarshallRRHeader( hReceiveBuffer, pRRHeader );
 181                 BAIL_ON_ERROR( dwError );
 182
 183                 dwError =
 184                         DNSUnmarshallRData( hReceiveBuffer,
 185                                             pRRHeader->wRDataSize, &pRRData,
 186                                             &dwRead );
 187                 BAIL_ON_ERROR( dwError );
 188
 189                 dwError =
 190                         DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 191                                            ( void * ) &pDNSRRRecord );
 192                 BAIL_ON_ERROR( dwError );
 193
 194                 memcpy( &pDNSRRRecord->RRHeader, pRRHeader,
 195                         sizeof( DNS_RR_HEADER ) );
 196                 pDNSRRRecord->pRData = pRRData;
 197
 198                 *( ppDNSUpdateRRRecords + i ) = pDNSRRRecord;
 199         }
 200
 201         *pppDNSUpdateRRRecords = ppDNSUpdateRRRecords;
 202
 203         return dwError;
 204
 205       error:
 206
 207         return dwError;
 208
 209 }
 210
 211 /*********************************************************************
 212 *********************************************************************/
 213
 214 static int32 DNSUpdateUnmarshallZoneSection( HANDLE hReceiveBuffer,
 215                                 int16 wZones,
 216                                 DNS_ZONE_RECORD * **pppDNSZoneRecords )
 217 {
 218         int32 dwError = 0;
 219         int32 i = 0;
 220         int32 dwRead = 0;
 221         DNS_ZONE_RECORD *pDNSZoneRecord = NULL;
 222         DNS_ZONE_RECORD **ppDNSZoneRecords = NULL;
 223         int16 wnZoneClass = 0;
 224         int16 wnZoneType = 0;
 225
 226
 227         dwError = DNSAllocateMemory( wZones * sizeof( DNS_ZONE_RECORD * ),
 228                                      ( void * ) &ppDNSZoneRecords );
 229         BAIL_ON_ERROR( dwError );
 230
 231         for ( i = 0; i < wZones; i++ ) {
 232
 233                 dwError =
 234                         DNSAllocateMemory( sizeof( DNS_ZONE_RECORD ),
 235                                            ( void * ) &pDNSZoneRecord );
 236                 BAIL_ON_ERROR( dwError );
 237
 238                 dwError =
 239                         DNSUnmarshallDomainName( hReceiveBuffer,
 240                                                  &pDNSZoneRecord->
 241                                                  pDomainName );
 242                 BAIL_ON_ERROR( dwError );
 243
 244                 dwError =
 245                         DNSUnmarshallBuffer( hReceiveBuffer,
 246                                              ( uint8 * ) & wnZoneType,
 247                                              ( int32 ) sizeof( int16 ),
 248                                              &dwRead );
 249                 BAIL_ON_ERROR( dwError );
 250                 pDNSZoneRecord->wZoneType = ntohs( wnZoneType );
 251
 252                 dwError =
 253                         DNSUnmarshallBuffer( hReceiveBuffer,
 254                                              ( uint8 * ) & wnZoneClass,
 255                                              ( int32 ) sizeof( int16 ),
 256                                              &dwRead );
 257                 BAIL_ON_ERROR( dwError );
 258                 pDNSZoneRecord->wZoneClass = ntohs( wnZoneClass );
 259
 260                 *( ppDNSZoneRecords + i ) = pDNSZoneRecord;
 261         }
 262
 263         *pppDNSZoneRecords = ppDNSZoneRecords;
 264         return dwError;
 265
 266       error:
 267
 268         return dwError;
 269 }
 270
 271
 272 /*********************************************************************
 273 *********************************************************************/
 274
 275 int32 DNSUpdateReceiveUpdateResponse( HANDLE hDNSHandle,
 276                                 DNS_UPDATE_RESPONSE ** ppDNSResponse )
 277 {
 278         DNS_UPDATE_RESPONSE *pDNSResponse = NULL;
 279         int32 dwError = 0;
 280         int16 wnIdentification, wIdentification = 0;
 281         int16 wnParameter, wParameter = 0;
 282         int16 wnZones, wZones = 0;
 283         int16 wnPRs, wPRs = 0;
 284         int16 wnAdditionals, wAdditionals = 0;
 285         int16 wnUpdates, wUpdates = 0;
 286         int32 dwRead = 0;
 287         DNS_RR_RECORD **ppDNSPRRecords = NULL;
 288         DNS_RR_RECORD **ppDNSAdditionalRecords = NULL;
 289         DNS_RR_RECORD **ppDNSUpdateRecords = NULL;
 290         DNS_ZONE_RECORD **ppDNSZoneRecords = NULL;
 291         HANDLE hRecvBuffer = ( HANDLE ) NULL;
 292
 293         dwError = DNSCreateReceiveBuffer( &hRecvBuffer );
 294         BAIL_ON_ERROR( dwError );
 295
 296         dwError = DNSReceiveBufferContext( hDNSHandle, hRecvBuffer, &dwRead );
 297         BAIL_ON_ERROR( dwError );
 298
 299 #if 0
 300         dwError = DNSDumpRecvBufferContext( hRecvBuffer );
 301         BAIL_ON_ERROR( dwError );
 302 #endif
 303
 304         dwError =
 305                 DNSUnmarshallBuffer( hRecvBuffer,
 306                                      ( uint8 * ) & wnIdentification,
 307                                      sizeof( int16 ), &dwRead );
 308         BAIL_ON_ERROR( dwError );
 309         wIdentification = ntohs( wnIdentification );
 310
 311         dwError =
 312                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnParameter,
 313                                      sizeof( int16 ), &dwRead );
 314         BAIL_ON_ERROR( dwError );
 315         wParameter = ntohs( wnParameter );
 316
 317
 318         dwError =
 319                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnZones,
 320                                      sizeof( int16 ), &dwRead );
 321         BAIL_ON_ERROR( dwError );
 322         wZones = ntohs( wnZones );
 323
 324
 325         dwError =
 326                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnPRs,
 327                                      sizeof( int16 ), &dwRead );
 328         BAIL_ON_ERROR( dwError );
 329         wPRs = ntohs( wnPRs );
 330
 331
 332         dwError =
 333                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnUpdates,
 334                                      sizeof( int16 ), &dwRead );
 335         BAIL_ON_ERROR( dwError );
 336         wUpdates = ntohs( wnUpdates );
 337
 338         dwError =
 339                 DNSUnmarshallBuffer( hRecvBuffer, ( uint8 * ) & wnAdditionals,
 340                                      sizeof( int16 ), &dwRead );
 341         BAIL_ON_ERROR( dwError );
 342         wAdditionals = ntohs( wnAdditionals );
 343
 344
 345         if ( wZones ) {
 346                 dwError =
 347                         DNSUpdateUnmarshallZoneSection( hRecvBuffer, wZones,
 348                                                         &ppDNSZoneRecords );
 349                 BAIL_ON_ERROR( dwError );
 350         }
 351
 352         if ( wPRs ) {
 353                 dwError =
 354                         DNSUpdateUnmarshallPRSection( hRecvBuffer, wPRs,
 355                                                       &ppDNSPRRecords );
 356                 BAIL_ON_ERROR( dwError );
 357         }
 358
 359         if ( wUpdates ) {
 360                 dwError =
 361                         DNSUpdateUnmarshallUpdateSection( hRecvBuffer,
 362                                                           wUpdates,
 363                                                           &ppDNSUpdateRecords );
 364                 BAIL_ON_ERROR( dwError );
 365         }
 366
 367         if ( wAdditionals ) {
 368                 dwError =
 369                         DNSUpdateUnmarshallAdditionalSection( hRecvBuffer,
 370                                                               wAdditionals,
 371                                                               &ppDNSAdditionalRecords );
 372                 BAIL_ON_ERROR( dwError );
 373         }
 374
 375         dwError = DNSUpdateAllocateResponse( &pDNSResponse );
 376         BAIL_ON_ERROR( dwError );
 377
 378         pDNSResponse->wIdentification = wIdentification;
 379         pDNSResponse->wParameter = wParameter;
 380         pDNSResponse->wZones = wZones;
 381         pDNSResponse->wPRs = wPRs;
 382         pDNSResponse->wUpdates = wUpdates;
 383         pDNSResponse->wAdditionals = wAdditionals;
 384
 385         pDNSResponse->ppZoneRRSet = ppDNSZoneRecords;
 386         pDNSResponse->ppPRRRSet = ppDNSPRRecords;
 387         pDNSResponse->ppUpdateRRSet = ppDNSUpdateRecords;
 388         pDNSResponse->ppAdditionalRRSet = ppDNSAdditionalRecords;
 389
 390         *ppDNSResponse = pDNSResponse;
 391
 392
 393       error:
 394
 395         return dwError;
 396 }
 397