source/libaddns/dnsrecord.c

   1 /*
   2   Linux DNS client library implementation
   3   Copyright (C) 2006 Krishna Ganugapati <krishnag@centeris.com>
   4   Copyright (C) 2006 Gerald Carter <jerry@samba.org>
   5
   6      ** NOTE! The following LGPL license applies to the libaddns
   7      ** library. This does NOT imply that all of Samba is released
   8      ** under the LGPL
   9
  10   This library is free software; you can redistribute it and/or
  11   modify it under the terms of the GNU Lesser General Public
  12   License as published by the Free Software Foundation; either
  13   version 2.1 of the License, or (at your option) any later version.
  14
  15   This library is distributed in the hope that it will be useful,
  16   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18   Lesser General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public
  21   License along with this library; if not, write to the Free Software
  22   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23   02110-1301  USA
  24 */
  25
  26 #include "dns.h"
  27
  28 /*********************************************************************
  29 *********************************************************************/
  30
  31 int32 DNSCreateDeleteRecord( char *szHost, int16 wClass,
  32                              int16 wType, DNS_RR_RECORD ** ppDNSRecord )
  33 {
  34         int32 dwError = 0;
  35         DNS_RR_RECORD *pDNSRRRecord = NULL;
  36         DNS_DOMAIN_NAME *pDomainName = NULL;
  37
  38         dwError = DNSDomainNameFromString( szHost, &pDomainName );
  39         BAIL_ON_ERROR( dwError );
  40
  41         dwError = DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
  42                                      ( void * ) &pDNSRRRecord );
  43         BAIL_ON_ERROR( dwError );
  44
  45         pDNSRRRecord->RRHeader.dwTTL = 0;
  46         pDNSRRRecord->RRHeader.wClass = wClass;
  47         pDNSRRRecord->RRHeader.wType = wType;
  48         pDNSRRRecord->RRHeader.pDomainName = pDomainName;
  49         pDNSRRRecord->RRHeader.wRDataSize = 0;
  50
  51         *ppDNSRecord = pDNSRRRecord;
  52
  53         return dwError;
  54       error:
  55
  56         if ( pDomainName ) {
  57                 DNSFreeDomainName( pDomainName );
  58         }
  59         if ( pDNSRRRecord ) {
  60                 DNSFreeMemory( pDNSRRRecord );
  61         }
  62
  63         *ppDNSRecord = NULL;
  64         return dwError;
  65 }
  66
  67 /*********************************************************************
  68 *********************************************************************/
  69
  70 int32 DNSCreateARecord( char *szHost, int16 wClass,
  71                   int16 wType, int32 dwIP, DNS_RR_RECORD ** ppDNSRecord )
  72 {
  73         int32 dwError = 0;
  74         DNS_RR_RECORD *pDNSRRRecord = NULL;
  75         DNS_DOMAIN_NAME *pDomainName = NULL;
  76         uint8 *pRData = NULL;
  77         int32 dwnIP = 0;
  78
  79         dwError = DNSDomainNameFromString( szHost, &pDomainName );
  80         BAIL_ON_ERROR( dwError );
  81
  82         dwError =
  83                 DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
  84                                    ( void * ) &pDNSRRRecord );
  85         BAIL_ON_ERROR( dwError );
  86
  87         pDNSRRRecord->RRHeader.wType = wType;
  88         pDNSRRRecord->RRHeader.pDomainName = pDomainName;
  89
  90         pDNSRRRecord->RRHeader.wClass = wClass;
  91         pDNSRRRecord->RRHeader.wRDataSize = 0;
  92         pDNSRRRecord->RRHeader.dwTTL = 0;
  93
  94         if ( wClass != DNS_CLASS_ANY ) {
  95                 pDNSRRRecord->RRHeader.dwTTL = DNS_ONE_DAY_IN_SECS;
  96                 pDNSRRRecord->RRHeader.wRDataSize = sizeof( int32 );
  97                 dwError =
  98                         DNSAllocateMemory( sizeof( int32 ),
  99                                            ( void * ) &pRData );
 100                 dwnIP = htonl( dwIP );
 101                 memcpy( pRData, &dwnIP, sizeof( int32 ) );
 102                 pDNSRRRecord->pRData = pRData;
 103         }
 104
 105         *ppDNSRecord = pDNSRRRecord;
 106
 107         return dwError;
 108       error:
 109
 110         if ( pDomainName ) {
 111                 DNSFreeDomainName( pDomainName );
 112         }
 113         if ( pDNSRRRecord ) {
 114                 DNSFreeMemory( pDNSRRRecord );
 115         }
 116
 117         if ( pDNSRRRecord ) {
 118                 DNSFreeMemory( pRData );
 119         }
 120         *ppDNSRecord = NULL;
 121         return dwError;
 122 }
 123
 124 /*********************************************************************
 125 *********************************************************************/
 126
 127 int32 DNSCreateTKeyRecord( char *szKeyName, uint8 * pKeyData,
 128                      int16 wKeySize, DNS_RR_RECORD ** ppDNSRecord )
 129 {
 130         int32 dwError = 0;
 131         DNS_RR_RECORD *pDNSRecord = NULL;
 132         DNS_DOMAIN_NAME *pAlgorithmName = NULL;
 133         DNS_DOMAIN_NAME *pDomainName = NULL;
 134         time_t t;
 135
 136         int32 dwRDataSize = 0;
 137         int32 dwnInception, dwInception = 0;
 138         int32 dwnExpiration, dwExpiration = 0;
 139         int16 wnMode, wMode = 0;
 140         int16 wnError, wError = 0;
 141         int16 wnKeySize = 0;
 142         int16 wnOtherSize, wOtherSize = 0;
 143
 144         int32 dwAlgorithmLen = 0;
 145         int32 dwCopied = 0;
 146         int32 dwOffset = 0;
 147
 148         uint8 *pRData = NULL;
 149
 150         char szTemp[20];
 151
 152         dwError =
 153                 DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 154                                    ( void * ) &pDNSRecord );
 155         BAIL_ON_ERROR( dwError );
 156
 157         dwError = DNSDomainNameFromString( szKeyName, &pDomainName );
 158         BAIL_ON_ERROR( dwError );
 159
 160         strncpy( szTemp, "gss.microsoft.com", sizeof( szTemp ) );
 161         dwError = DNSDomainNameFromString( szTemp, &pAlgorithmName );
 162         BAIL_ON_ERROR( dwError );
 163
 164         pDNSRecord->RRHeader.dwTTL = 0;
 165         pDNSRecord->RRHeader.pDomainName = pDomainName;
 166         pDNSRecord->RRHeader.wClass = DNS_CLASS_ANY;
 167         pDNSRecord->RRHeader.wType = QTYPE_TKEY;
 168
 169         time( &t );
 170         dwExpiration = ( int32 ) t + DNS_ONE_DAY_IN_SECS;
 171         dwInception = ( int32 ) t;
 172         wError = 0;
 173         wMode = 3;
 174
 175         dwError = DNSGetDomainNameLength( pAlgorithmName, &dwAlgorithmLen );
 176         BAIL_ON_ERROR( dwError );
 177
 178         dwRDataSize = dwAlgorithmLen +
 179                 sizeof( dwExpiration ) + sizeof( dwInception ) +
 180                 sizeof( wError ) + sizeof( wMode ) + +sizeof( wError ) +
 181                 sizeof( wKeySize ) + wKeySize + sizeof( wOtherSize ) +
 182                 wOtherSize;
 183
 184         dwError = DNSAllocateMemory( dwRDataSize, ( void * ) &pRData );
 185         BAIL_ON_ERROR( dwError );
 186
 187         dwnInception = htonl( dwInception );
 188         dwnExpiration = htonl( dwExpiration );
 189         wnMode = htons( wMode );
 190         wnError = htons( wError );
 191         wnKeySize = htons( wKeySize );
 192         wnOtherSize = htons( wOtherSize );
 193
 194         dwError = DNSCopyDomainName( pRData, pAlgorithmName, &dwCopied );
 195         BAIL_ON_ERROR( dwError );
 196         dwOffset += dwCopied;
 197
 198         memcpy( pRData + dwOffset, &dwnInception, sizeof( int32 ) );
 199         dwOffset += sizeof( int32 );
 200
 201         memcpy( pRData + dwOffset, &dwnExpiration, sizeof( int32 ) );
 202         dwOffset += sizeof( int32 );
 203
 204         memcpy( pRData + dwOffset, &wnMode, sizeof( int16 ) );
 205         dwOffset += sizeof( int16 );
 206
 207         memcpy( pRData + dwOffset, &wnError, sizeof( int16 ) );
 208         dwOffset += sizeof( int16 );
 209
 210         memcpy( pRData + dwOffset, &wnKeySize, sizeof( int16 ) );
 211         dwOffset += sizeof( int16 );
 212
 213         memcpy( pRData + dwOffset, pKeyData, wKeySize );
 214         dwOffset += wKeySize;
 215
 216         memcpy( pRData + dwOffset, &wnOtherSize, sizeof( int16 ) );
 217         dwOffset += sizeof( int16 );
 218
 219         pDNSRecord->RRHeader.wRDataSize = ( int16 ) dwRDataSize;
 220
 221         pDNSRecord->pRData = pRData;
 222         *ppDNSRecord = pDNSRecord;
 223
 224         return dwError;
 225
 226       error:
 227
 228
 229         if ( pDNSRecord ) {
 230                 DNSFreeMemory( pDNSRecord );
 231         }
 232
 233         if ( pDomainName ) {
 234                 DNSFreeDomainName( pDomainName );
 235         }
 236
 237         if ( pAlgorithmName ) {
 238                 DNSFreeDomainName( pAlgorithmName );
 239         }
 240
 241         *ppDNSRecord = NULL;
 242         return dwError;
 243 }
 244
 245 /*********************************************************************
 246 *********************************************************************/
 247
 248 int32 DNSCreateTSIGRecord( char *szKeyName, int32 dwTimeSigned,
 249                      int16 wFudge, int16 wOriginalID, uint8 * pMac,
 250                      int16 wMacSize, DNS_RR_RECORD ** ppDNSRecord )
 251 {
 252         int32 dwError = 0;
 253         DNS_RR_RECORD *pDNSRecord = NULL;
 254         DNS_DOMAIN_NAME *pAlgorithmName = NULL;
 255         DNS_DOMAIN_NAME *pDomainName = NULL;
 256         time_t t;
 257
 258         int32 dwRDataSize = 0;
 259
 260         int16 wnFudge = 0;
 261         int16 wnError = 0, wError = 0;
 262         int16 wnMacSize = 0;
 263         int16 wnOriginalID = 0;
 264         int16 wnOtherLen = 0, wOtherLen = 0;
 265
 266         int32 dwAlgorithmLen = 0;
 267         int32 dwCopied = 0;
 268         int32 dwOffset = 0;
 269
 270         uint8 *pRData = NULL;
 271
 272         int32 dwnTimeSigned = 0;
 273         int16 wnTimePrefix = 0;
 274         int16 wTimePrefix = 0;
 275
 276         char szTemp[20];
 277
 278         dwError =
 279                 DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 280                                    ( void * ) &pDNSRecord );
 281         BAIL_ON_ERROR( dwError );
 282
 283         dwError = DNSDomainNameFromString( szKeyName, &pDomainName );
 284         BAIL_ON_ERROR( dwError );
 285
 286         strncpy( szTemp, "gss.microsoft.com", sizeof( szTemp ) );
 287         dwError = DNSDomainNameFromString( szTemp, &pAlgorithmName );
 288         BAIL_ON_ERROR( dwError );
 289
 290         pDNSRecord->RRHeader.dwTTL = 0;
 291         pDNSRecord->RRHeader.pDomainName = pDomainName;
 292         pDNSRecord->RRHeader.wClass = DNS_CLASS_ANY;
 293         pDNSRecord->RRHeader.wType = QTYPE_TSIG;
 294
 295         /* This needs to be a 48bit value - 6 octets. */
 296
 297         time( &t );
 298
 299         dwError = DNSGetDomainNameLength( pAlgorithmName, &dwAlgorithmLen );
 300         BAIL_ON_ERROR( dwError );
 301
 302         dwRDataSize = dwAlgorithmLen + 6 + sizeof( wFudge ) + sizeof( wMacSize ) +
 303                 wMacSize + sizeof( wOriginalID ) + sizeof( wError ) +
 304                 sizeof( wOtherLen );
 305
 306         dwError = DNSAllocateMemory( dwRDataSize, ( void * ) &pRData );
 307         BAIL_ON_ERROR( dwError );
 308
 309         /* Convert t to 48 bit network order */
 310
 311         wnTimePrefix = htons( wTimePrefix );
 312         dwnTimeSigned = htonl( dwTimeSigned );
 313         wnFudge = htons( wFudge );
 314         wnMacSize = htons( wMacSize );
 315         wnOriginalID = htons( wOriginalID );
 316         wnError = htons( wError );
 317         wnOtherLen = htons( wOtherLen );
 318
 319         dwError = DNSCopyDomainName( pRData, pAlgorithmName, &dwCopied );
 320         BAIL_ON_ERROR( dwError );
 321         dwOffset += dwCopied;
 322
 323         memcpy( pRData + dwOffset, &wnTimePrefix, sizeof( int16 ) );
 324         dwOffset += sizeof( int16 );
 325
 326         memcpy( pRData + dwOffset, &dwnTimeSigned, sizeof( int32 ) );
 327         dwOffset += sizeof( int32 );
 328
 329         memcpy( pRData + dwOffset, &wnFudge, sizeof( int16 ) );
 330         dwOffset += sizeof( int16 );
 331
 332
 333         memcpy( pRData + dwOffset, &wnMacSize, sizeof( int16 ) );
 334         dwOffset += sizeof( int16 );
 335
 336         memcpy( pRData + dwOffset, pMac, wMacSize );
 337         dwOffset += wMacSize;
 338
 339         memcpy( pRData + dwOffset, &wnOriginalID, sizeof( int16 ) );
 340         dwOffset += sizeof( int16 );
 341
 342         memcpy( pRData + dwOffset, &wnError, sizeof( int16 ) );
 343         dwOffset += sizeof( int16 );
 344
 345         memcpy( pRData + dwOffset, &wnOtherLen, sizeof( int16 ) );
 346         dwOffset += sizeof( int16 );
 347
 348         pDNSRecord->RRHeader.wRDataSize = ( int16 ) dwRDataSize;
 349
 350         pDNSRecord->pRData = pRData;
 351         *ppDNSRecord = pDNSRecord;
 352
 353         return dwError;
 354
 355       error:
 356
 357
 358         if ( pDNSRecord ) {
 359                 DNSFreeMemory( pDNSRecord );
 360         }
 361
 362         if ( pDomainName ) {
 363                 DNSFreeDomainName( pDomainName );
 364         }
 365
 366         if ( pAlgorithmName ) {
 367                 DNSFreeDomainName( pAlgorithmName );
 368         }
 369
 370         *ppDNSRecord = NULL;
 371         return dwError;
 372 }
 373
 374 /*********************************************************************
 375 *********************************************************************/
 376
 377 int32 DNSCreateQuestionRecord( char *pszQName, int16 wQType,
 378                                int16 wQClass,
 379                                DNS_QUESTION_RECORD ** ppDNSQuestionRecord )
 380 {
 381         int32 dwError = 0;
 382         DNS_QUESTION_RECORD *pDNSQuestionRecord = NULL;
 383         DNS_DOMAIN_NAME *pDomainName = NULL;
 384
 385         dwError = DNSDomainNameFromString( pszQName, &pDomainName );
 386         BAIL_ON_ERROR( dwError );
 387
 388         dwError =
 389                 DNSAllocateMemory( sizeof( DNS_QUESTION_RECORD ),
 390                                    ( void * ) &pDNSQuestionRecord );
 391         BAIL_ON_ERROR( dwError );
 392
 393         pDNSQuestionRecord->pDomainName = pDomainName;
 394         pDNSQuestionRecord->wQueryClass = wQClass;
 395         pDNSQuestionRecord->wQueryType = wQType;
 396
 397         *ppDNSQuestionRecord = pDNSQuestionRecord;
 398
 399         return dwError;
 400       error:
 401
 402         if ( pDomainName ) {
 403                 DNSFreeDomainName( pDomainName );
 404         }
 405         if ( pDNSQuestionRecord ) {
 406                 DNSFreeMemory( pDNSQuestionRecord );
 407         }
 408         *ppDNSQuestionRecord = NULL;
 409         return dwError;
 410 }
 411
 412 /*********************************************************************
 413 *********************************************************************/
 414
 415 int32 DNSCreateZoneRecord( const char *pszZName, DNS_ZONE_RECORD ** ppDNSZoneRecord )
 416 {
 417         int32 dwError = 0;
 418         DNS_ZONE_RECORD *pDNSZoneRecord = NULL;
 419         DNS_DOMAIN_NAME *pDomainName = NULL;
 420
 421         dwError = DNSDomainNameFromString( pszZName, &pDomainName );
 422         BAIL_ON_ERROR( dwError );
 423
 424         dwError =
 425                 DNSAllocateMemory( sizeof( DNS_ZONE_RECORD ),
 426                                    ( void * ) &pDNSZoneRecord );
 427         BAIL_ON_ERROR( dwError );
 428
 429         pDNSZoneRecord->pDomainName = pDomainName;
 430         pDNSZoneRecord->wZoneClass = DNS_CLASS_IN;
 431         pDNSZoneRecord->wZoneType = QTYPE_SOA;
 432
 433         *ppDNSZoneRecord = pDNSZoneRecord;
 434
 435         return dwError;
 436       error:
 437
 438         if ( pDomainName ) {
 439                 DNSFreeDomainName( pDomainName );
 440         }
 441         if ( pDNSZoneRecord ) {
 442                 DNSFreeMemory( pDNSZoneRecord );
 443         }
 444         *ppDNSZoneRecord = NULL;
 445         return dwError;
 446 }
 447
 448 int32 DNSFreeZoneRecord( DNS_ZONE_RECORD * pDNSZoneRecord )
 449 {
 450         int32 dwError = 0;
 451
 452         return dwError;
 453
 454 }
 455
 456 /*********************************************************************
 457 *********************************************************************/
 458
 459 int32 DNSCreateNameInUseRecord( char *pszName, int32 qtype,
 460                                 struct in_addr * ip,
 461                                 DNS_RR_RECORD * *ppDNSRRRecord )
 462 {
 463         int32 dwError = 0;
 464         DNS_RR_RECORD *pDNSRRRecord = NULL;
 465         DNS_DOMAIN_NAME *pDomainName = NULL;
 466
 467         dwError = DNSDomainNameFromString( pszName, &pDomainName );
 468         BAIL_ON_ERROR( dwError );
 469
 470         dwError =
 471                 DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 472                                    ( void * ) &pDNSRRRecord );
 473         BAIL_ON_ERROR( dwError );
 474
 475         pDNSRRRecord->RRHeader.pDomainName = pDomainName;
 476         pDNSRRRecord->RRHeader.dwTTL = 0;
 477         pDNSRRRecord->RRHeader.wType = qtype;
 478
 479         if ( !ip ) {
 480                 pDNSRRRecord->RRHeader.wClass = DNS_CLASS_ANY;
 481                 pDNSRRRecord->RRHeader.wRDataSize = 0;
 482         } else {
 483                 pDNSRRRecord->RRHeader.wClass = DNS_CLASS_IN;
 484                 pDNSRRRecord->RRHeader.wRDataSize = 4;
 485                 dwError =
 486                         DNSAllocateMemory( 4,
 487                                            ( void * ) &pDNSRRRecord->
 488                                            pRData );
 489                 BAIL_ON_ERROR( dwError );
 490                 memcpy( pDNSRRRecord->pRData, &ip->s_addr, 4 );
 491         }
 492
 493         *ppDNSRRRecord = pDNSRRRecord;
 494
 495         return dwError;
 496       error:
 497
 498         if ( pDomainName ) {
 499                 DNSFreeDomainName( pDomainName );
 500         }
 501         if ( pDNSRRRecord ) {
 502                 DNSFreeMemory( pDNSRRRecord );
 503         }
 504         *ppDNSRRRecord = NULL;
 505
 506         return dwError;
 507 }
 508
 509 /*********************************************************************
 510 *********************************************************************/
 511
 512 int32 DNSCreateNameNotInUseRecord( char *pszName, int32 qtype,
 513                                    DNS_RR_RECORD * *ppDNSRRRecord )
 514 {
 515         int32 dwError = 0;
 516         DNS_RR_RECORD *pDNSRRRecord = NULL;
 517         DNS_DOMAIN_NAME *pDomainName = NULL;
 518
 519         dwError = DNSDomainNameFromString( pszName, &pDomainName );
 520         BAIL_ON_ERROR( dwError );
 521
 522         dwError =
 523                 DNSAllocateMemory( sizeof( DNS_RR_RECORD ),
 524                                    ( void * ) &pDNSRRRecord );
 525         BAIL_ON_ERROR( dwError );
 526
 527         pDNSRRRecord->RRHeader.pDomainName = pDomainName;
 528         pDNSRRRecord->RRHeader.wClass = DNS_CLASS_NONE;
 529         pDNSRRRecord->RRHeader.wType = qtype;
 530         pDNSRRRecord->RRHeader.dwTTL = 0;
 531         pDNSRRRecord->RRHeader.wRDataSize = 0;
 532
 533         *ppDNSRRRecord = pDNSRRRecord;
 534
 535         return dwError;
 536       error:
 537
 538         if ( pDomainName ) {
 539                 DNSFreeDomainName( pDomainName );
 540         }
 541         if ( pDNSRRRecord ) {
 542                 DNSFreeMemory( pDNSRRRecord );
 543         }
 544         *ppDNSRRRecord = NULL;
 545         return dwError;
 546
 547 }
 548