mDNSWindows/DLLX/DNSSDService.cpp

   1 /* -*- Mode: C; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2009 Apple Computer, Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19
  20 #pragma warning(disable:4995)
  21
  22
  23
  24 #include "stdafx.h"
  25
  26 #include <strsafe.h>
  27
  28 #include "DNSSDService.h"
  29
  30 #include "DNSSDEventManager.h"
  31
  32 #include "DNSSDRecord.h"
  33
  34 #include "TXTRecord.h"
  35
  36 #include "StringServices.h"
  37
  38 #include <DebugServices.h>
  39
  40
  41
  42
  43
  44 #define WM_SOCKET (WM_APP + 100)
  45
  46
  47
  48
  49
  50 // CDNSSDService
  51
  52
  53
  54 BOOL                                            CDNSSDService::m_registeredWindowClass  = FALSE;
  55
  56 HWND                                            CDNSSDService::m_hiddenWindow                   = NULL;
  57
  58 CDNSSDService::SocketMap        CDNSSDService::m_socketMap;
  59
  60
  61
  62
  63
  64 HRESULT CDNSSDService::FinalConstruct()
  65
  66 {
  67
  68         DNSServiceErrorType     err     = 0;
  69
  70         HRESULT                         hr      = S_OK;
  71
  72
  73
  74         m_isPrimary = TRUE;
  75
  76         err = DNSServiceCreateConnection( &m_primary );
  77
  78         require_action( !err, exit, hr = E_FAIL );
  79
  80
  81
  82         if ( !m_hiddenWindow )
  83
  84         {
  85
  86                 TCHAR windowClassName[ 256 ];
  87
  88
  89
  90                 StringCchPrintf( windowClassName, sizeof( windowClassName ) / sizeof( TCHAR ), TEXT( "Bonjour Hidden Window %d" ), GetProcessId( NULL ) );
  91
  92
  93
  94                 if ( !m_registeredWindowClass )
  95
  96                 {
  97
  98                         WNDCLASS        wc;
  99
 100                         ATOM            atom;
 101
 102
 103
 104                         wc.style                        = 0;
 105
 106                         wc.lpfnWndProc          = WndProc;
 107
 108                         wc.cbClsExtra           = 0;
 109
 110                         wc.cbWndExtra           = 0;
 111
 112                         wc.hInstance            = NULL;
 113
 114                         wc.hIcon                        = NULL;
 115
 116                         wc.hCursor                      = NULL;
 117
 118                         wc.hbrBackground        = NULL;
 119
 120                         wc.lpszMenuName         = NULL;
 121
 122                         wc.lpszClassName        = windowClassName;
 123
 124
 125
 126                         atom = RegisterClass(&wc);
 127
 128                         require_action( atom != NULL, exit, hr = E_FAIL );
 129
 130
 131
 132                         m_registeredWindowClass = TRUE;
 133
 134                 }
 135
 136
 137
 138                 m_hiddenWindow = CreateWindow( windowClassName, windowClassName, WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL, GetModuleHandle( NULL ), NULL );
 139
 140                 require_action( m_hiddenWindow != NULL, exit, hr = E_FAIL );
 141
 142         }
 143
 144
 145
 146         err = WSAAsyncSelect( DNSServiceRefSockFD( m_primary ), m_hiddenWindow, WM_SOCKET, FD_READ );
 147
 148         require_action( !err, exit, hr = E_FAIL );
 149
 150
 151
 152         m_socketMap[ DNSServiceRefSockFD( m_primary ) ] = this;
 153
 154
 155
 156 exit:
 157
 158
 159
 160         return hr;
 161
 162 }
 163
 164
 165
 166
 167
 168 void CDNSSDService::FinalRelease()
 169
 170 {
 171
 172         dlog( kDebugLevelTrace, "FinalRelease()\n" );
 173
 174         Stop();
 175
 176 }
 177
 178
 179
 180
 181
 182 STDMETHODIMP CDNSSDService::EnumerateDomains(DNSSDFlags flags, ULONG ifIndex, IDNSSDEventManager *eventManager, IDNSSDService **service)
 183
 184 {
 185
 186         CComObject<CDNSSDService>       *       object  = NULL;
 187
 188         DNSServiceRef                                   subord  = NULL;
 189
 190         DNSServiceErrorType                             err             = 0;
 191
 192         HRESULT                                                 hr              = 0;
 193
 194
 195
 196         check( m_primary );
 197
 198
 199
 200         // Initialize
 201
 202         *service = NULL;
 203
 204
 205
 206         try
 207
 208         {
 209
 210                 object = new CComObject<CDNSSDService>();
 211
 212         }
 213
 214         catch ( ... )
 215
 216         {
 217
 218                 object = NULL;
 219
 220         }
 221
 222
 223
 224         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 225
 226         object->AddRef();
 227
 228
 229
 230         subord = m_primary;
 231
 232         err = DNSServiceEnumerateDomains( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, ( DNSServiceDomainEnumReply ) &DomainEnumReply, object );
 233
 234         require_noerr( err, exit );
 235
 236
 237
 238         object->SetPrimaryRef( m_primary );
 239
 240         object->SetSubordRef( subord );
 241
 242         object->SetEventManager( eventManager );
 243
 244
 245
 246         *service = object;
 247
 248
 249
 250 exit:
 251
 252
 253
 254         if ( err && object )
 255
 256         {
 257
 258                 object->Release();
 259
 260         }
 261
 262
 263
 264         return err;
 265
 266 }
 267
 268
 269
 270
 271
 272 STDMETHODIMP CDNSSDService::Browse(DNSSDFlags flags, ULONG ifIndex, BSTR regtype, BSTR domain, IDNSSDEventManager* eventManager, IDNSSDService** service )
 273
 274 {
 275
 276         CComObject<CDNSSDService>       *       object          = NULL;
 277
 278         std::string                                             regtypeUTF8;
 279
 280         std::string                                             domainUTF8;
 281
 282         DNSServiceRef                                   subord          = NULL;
 283
 284         DNSServiceErrorType                             err                     = 0;
 285
 286         HRESULT                                                 hr                      = 0;
 287
 288         BOOL                                                    ok;
 289
 290
 291
 292         check( m_primary );
 293
 294
 295
 296         // Initialize
 297
 298         *service = NULL;
 299
 300
 301
 302         // Convert BSTR params to utf8
 303
 304         ok = BSTRToUTF8( regtype, regtypeUTF8 );
 305
 306         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 307
 308         ok = BSTRToUTF8( domain, domainUTF8 );
 309
 310         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 311
 312
 313
 314         try
 315
 316         {
 317
 318                 object = new CComObject<CDNSSDService>();
 319
 320         }
 321
 322         catch ( ... )
 323
 324         {
 325
 326                 object = NULL;
 327
 328         }
 329
 330
 331
 332         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 333
 334         object->AddRef();
 335
 336
 337
 338         subord = m_primary;
 339
 340         err = DNSServiceBrowse( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, regtypeUTF8.c_str(), ( domainUTF8.size() > 0 ) ? domainUTF8.c_str() : NULL, ( DNSServiceBrowseReply ) &BrowseReply, object );
 341
 342         require_noerr( err, exit );
 343
 344
 345
 346         object->SetPrimaryRef( m_primary );
 347
 348         object->SetSubordRef( subord );
 349
 350         object->SetEventManager( eventManager );
 351
 352
 353
 354         *service = object;
 355
 356
 357
 358 exit:
 359
 360
 361
 362         if ( err && object )
 363
 364         {
 365
 366                 object->Release();
 367
 368         }
 369
 370
 371
 372         return err;
 373
 374 }
 375
 376
 377
 378
 379
 380 STDMETHODIMP CDNSSDService::Resolve(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, IDNSSDEventManager* eventManager, IDNSSDService** service)
 381
 382 {
 383
 384         CComObject<CDNSSDService>       *       object                  = NULL;
 385
 386         std::string                                             serviceNameUTF8;
 387
 388         std::string                                             regTypeUTF8;
 389
 390         std::string                                             domainUTF8;
 391
 392         DNSServiceRef                                   subord                  = NULL;
 393
 394         DNSServiceErrorType                             err                             = 0;
 395
 396         HRESULT                                                 hr                              = 0;
 397
 398         BOOL                                                    ok;
 399
 400
 401
 402         check( m_primary );
 403
 404
 405
 406         // Initialize
 407
 408         *service = NULL;
 409
 410
 411
 412         // Convert BSTR params to utf8
 413
 414         ok = BSTRToUTF8( serviceName, serviceNameUTF8 );
 415
 416         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 417
 418         ok = BSTRToUTF8( regType, regTypeUTF8 );
 419
 420         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 421
 422         ok = BSTRToUTF8( domain, domainUTF8 );
 423
 424         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 425
 426
 427
 428         try
 429
 430         {
 431
 432                 object = new CComObject<CDNSSDService>();
 433
 434         }
 435
 436         catch ( ... )
 437
 438         {
 439
 440                 object = NULL;
 441
 442         }
 443
 444
 445
 446         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 447
 448         object->AddRef();
 449
 450
 451
 452         subord = m_primary;
 453
 454         err = DNSServiceResolve( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), domainUTF8.c_str(), ( DNSServiceResolveReply ) &ResolveReply, object );
 455
 456         require_noerr( err, exit );
 457
 458
 459
 460         object->SetPrimaryRef( m_primary );
 461
 462         object->SetSubordRef( subord );
 463
 464         object->SetEventManager( eventManager );
 465
 466
 467
 468         *service = object;
 469
 470
 471
 472 exit:
 473
 474
 475
 476         if ( err && object )
 477
 478         {
 479
 480                 object->Release();
 481
 482         }
 483
 484
 485
 486         return err;
 487
 488 }
 489
 490
 491
 492
 493
 494 STDMETHODIMP CDNSSDService::Register(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, BSTR host, USHORT port, ITXTRecord *record, IDNSSDEventManager *eventManager, IDNSSDService **service)
 495
 496 {
 497
 498         CComObject<CDNSSDService>       *       object                  = NULL;
 499
 500         std::string                                             serviceNameUTF8;
 501
 502         std::string                                             regTypeUTF8;
 503
 504         std::string                                             domainUTF8;
 505
 506         std::string                                             hostUTF8;
 507
 508         const void                                      *       txtRecord               = NULL;
 509
 510         uint16_t                                                txtLen                  = 0;
 511
 512         DNSServiceRef                                   subord                  = NULL;
 513
 514         DNSServiceErrorType                             err                             = 0;
 515
 516         HRESULT                                                 hr                              = 0;
 517
 518         BOOL                                                    ok;
 519
 520
 521
 522         check( m_primary );
 523
 524
 525
 526         // Initialize
 527
 528         *service = NULL;
 529
 530
 531
 532         // Convert BSTR params to utf8
 533
 534         ok = BSTRToUTF8( serviceName, serviceNameUTF8 );
 535
 536         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 537
 538         ok = BSTRToUTF8( regType, regTypeUTF8 );
 539
 540         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 541
 542         ok = BSTRToUTF8( domain, domainUTF8 );
 543
 544         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 545
 546         ok = BSTRToUTF8( host, hostUTF8 );
 547
 548         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 549
 550
 551
 552         try
 553
 554         {
 555
 556                 object = new CComObject<CDNSSDService>();
 557
 558         }
 559
 560         catch ( ... )
 561
 562         {
 563
 564                 object = NULL;
 565
 566         }
 567
 568
 569
 570         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 571
 572         object->AddRef();
 573
 574
 575
 576         if ( record )
 577
 578         {
 579
 580                 CComObject< CTXTRecord > * realTXTRecord;
 581
 582
 583
 584                 realTXTRecord = ( CComObject< CTXTRecord >* ) record;
 585
 586
 587
 588                 txtRecord       = realTXTRecord->GetBytes();
 589
 590                 txtLen          = realTXTRecord->GetLen();
 591
 592         }
 593
 594
 595
 596         subord = m_primary;
 597
 598         err = DNSServiceRegister( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), ( domainUTF8.size() > 0 ) ? domainUTF8.c_str() : NULL, hostUTF8.c_str(), htons( port ), txtLen, txtRecord, ( DNSServiceRegisterReply ) &RegisterReply, object );
 599
 600         require_noerr( err, exit );
 601
 602
 603
 604         object->SetPrimaryRef( m_primary );
 605
 606         object->SetSubordRef( subord );
 607
 608         object->SetEventManager( eventManager );
 609
 610
 611
 612         *service = object;
 613
 614
 615
 616 exit:
 617
 618
 619
 620         if ( err && object )
 621
 622         {
 623
 624                 object->Release();
 625
 626         }
 627
 628
 629
 630         return err;
 631
 632 }
 633
 634
 635
 636
 637
 638 STDMETHODIMP CDNSSDService::QueryRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullname, DNSSDRRType rrtype, DNSSDRRClass rrclass, IDNSSDEventManager *eventManager, IDNSSDService **service)
 639
 640 {
 641
 642         CComObject<CDNSSDService>       *       object                  = NULL;
 643
 644         DNSServiceRef                                   subord                  = NULL;
 645
 646         std::string                                             fullNameUTF8;
 647
 648         DNSServiceErrorType                             err                             = 0;
 649
 650         HRESULT                                                 hr                              = 0;
 651
 652         BOOL                                                    ok;
 653
 654
 655
 656         check( m_primary );
 657
 658
 659
 660         // Initialize
 661
 662         *service = NULL;
 663
 664
 665
 666         // Convert BSTR params to utf8
 667
 668         ok = BSTRToUTF8( fullname, fullNameUTF8 );
 669
 670         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 671
 672
 673
 674         try
 675
 676         {
 677
 678                 object = new CComObject<CDNSSDService>();
 679
 680         }
 681
 682         catch ( ... )
 683
 684         {
 685
 686                 object = NULL;
 687
 688         }
 689
 690
 691
 692         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 693
 694         object->AddRef();
 695
 696
 697
 698         subord = m_primary;
 699
 700         err = DNSServiceQueryRecord( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, fullNameUTF8.c_str(), ( uint16_t ) rrtype, ( uint16_t ) rrclass, ( DNSServiceQueryRecordReply ) &QueryRecordReply, object );
 701
 702         require_noerr( err, exit );
 703
 704
 705
 706         object->SetPrimaryRef( m_primary );
 707
 708         object->SetSubordRef( subord );
 709
 710         object->SetEventManager( eventManager );
 711
 712
 713
 714         *service = object;
 715
 716
 717
 718 exit:
 719
 720
 721
 722         if ( err && object )
 723
 724         {
 725
 726                 object->Release();
 727
 728         }
 729
 730
 731
 732         return err;
 733
 734 }
 735
 736
 737
 738
 739
 740 STDMETHODIMP CDNSSDService::RegisterRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullName, DNSSDRRType rrtype, DNSSDRRClass rrclass, VARIANT rdata, ULONG ttl, IDNSSDEventManager* eventManager, IDNSSDRecord** record)
 741
 742 {
 743
 744         CComObject<CDNSSDRecord>        *       object                  = NULL;
 745
 746         DNSRecordRef                                    rref                    = NULL;
 747
 748         std::string                                             fullNameUTF8;
 749
 750         std::vector< BYTE >                             byteArray;
 751
 752         const void                                      *       byteArrayPtr    = NULL;
 753
 754         DNSServiceErrorType                             err                             = 0;
 755
 756         HRESULT                                                 hr                              = 0;
 757
 758         BOOL                                                    ok;
 759
 760
 761
 762         check( m_primary );
 763
 764
 765
 766         // Initialize
 767
 768         *object = NULL;
 769
 770
 771
 772         // Convert BSTR params to utf8
 773
 774         ok = BSTRToUTF8( fullName, fullNameUTF8 );
 775
 776         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 777
 778
 779
 780         // Convert the VARIANT
 781
 782         ok = VariantToByteArray( &rdata, byteArray );
 783
 784         require_action( ok, exit, err = kDNSServiceErr_Unknown );
 785
 786
 787
 788         try
 789
 790         {
 791
 792                 object = new CComObject<CDNSSDRecord>();
 793
 794         }
 795
 796         catch ( ... )
 797
 798         {
 799
 800                 object = NULL;
 801
 802         }
 803
 804
 805
 806         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 807
 808         object->AddRef();
 809
 810
 811
 812         err = DNSServiceRegisterRecord( m_primary, &rref, flags, ifIndex, fullNameUTF8.c_str(), rrtype, rrclass, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL, ttl, &RegisterRecordReply, object );
 813
 814         require_noerr( err, exit );
 815
 816
 817
 818         object->SetServiceObject( this );
 819
 820         object->SetRecordRef( rref );
 821
 822         this->SetEventManager( eventManager );
 823
 824
 825
 826         *record = object;
 827
 828
 829
 830 exit:
 831
 832
 833
 834         if ( err && object )
 835
 836         {
 837
 838                 object->Release();
 839
 840         }
 841
 842
 843
 844         return err;
 845
 846 }
 847
 848
 849
 850
 851
 852 STDMETHODIMP CDNSSDService::AddRecord(DNSSDFlags flags, DNSSDRRType rrtype, VARIANT rdata, ULONG ttl, IDNSSDRecord ** record)
 853
 854 {
 855
 856         CComObject<CDNSSDRecord>        *       object                  = NULL;
 857
 858         DNSRecordRef                                    rref                    = NULL;
 859
 860         std::vector< BYTE >                             byteArray;
 861
 862         const void                                      *       byteArrayPtr    = NULL;
 863
 864         DNSServiceErrorType                             err                             = 0;
 865
 866         HRESULT                                                 hr                              = 0;
 867
 868         BOOL                                                    ok;
 869
 870
 871
 872         check( m_primary );
 873
 874
 875
 876         // Initialize
 877
 878         *object = NULL;
 879
 880
 881
 882         // Convert the VARIANT
 883
 884         ok = VariantToByteArray( &rdata, byteArray );
 885
 886         require_action( ok, exit, err = kDNSServiceErr_Unknown );
 887
 888
 889
 890         try
 891
 892         {
 893
 894                 object = new CComObject<CDNSSDRecord>();
 895
 896         }
 897
 898         catch ( ... )
 899
 900         {
 901
 902                 object = NULL;
 903
 904         }
 905
 906
 907
 908         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
 909
 910         object->AddRef();
 911
 912
 913
 914         err = DNSServiceAddRecord( m_primary, &rref, flags, rrtype, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL, ttl );
 915
 916         require_noerr( err, exit );
 917
 918
 919
 920         object->SetServiceObject( this );
 921
 922         object->SetRecordRef( rref );
 923
 924
 925
 926         *record = object;
 927
 928
 929
 930 exit:
 931
 932
 933
 934         if ( err && object )
 935
 936         {
 937
 938                 object->Release();
 939
 940         }
 941
 942
 943
 944         return err;
 945
 946 }
 947
 948
 949
 950 STDMETHODIMP CDNSSDService::ReconfirmRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullName, DNSSDRRType rrtype, DNSSDRRClass rrclass, VARIANT rdata)
 951
 952 {
 953
 954         std::string                                             fullNameUTF8;
 955
 956         std::vector< BYTE >                             byteArray;
 957
 958         const void                                      *       byteArrayPtr    = NULL;
 959
 960         DNSServiceErrorType                             err                             = 0;
 961
 962         HRESULT                                                 hr                              = 0;
 963
 964         BOOL                                                    ok;
 965
 966
 967
 968         // Convert BSTR params to utf8
 969
 970         ok = BSTRToUTF8( fullName, fullNameUTF8 );
 971
 972         require_action( ok, exit, err = kDNSServiceErr_BadParam );
 973
 974
 975
 976         // Convert the VARIANT
 977
 978         ok = VariantToByteArray( &rdata, byteArray );
 979
 980         require_action( ok, exit, err = kDNSServiceErr_Unknown );
 981
 982
 983
 984         err = DNSServiceReconfirmRecord( flags, ifIndex, fullNameUTF8.c_str(), rrtype, rrclass, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL );
 985
 986         require_noerr( err, exit );
 987
 988
 989
 990 exit:
 991
 992
 993
 994         return err;
 995
 996 }
 997
 998
 999
1000
1001
1002 STDMETHODIMP CDNSSDService::GetProperty(BSTR prop, VARIANT * value )
1003
1004 {
1005
1006         std::string                     propUTF8;
1007
1008         std::vector< BYTE >     byteArray;
1009
1010         SAFEARRAY               *       psa                     = NULL;
1011
1012         BYTE                    *       pData           = NULL;
1013
1014         uint32_t                        elems           = 0;
1015
1016         DNSServiceErrorType     err                     = 0;
1017
1018         BOOL                            ok = TRUE;
1019
1020
1021
1022         // Convert BSTR params to utf8
1023
1024         ok = BSTRToUTF8( prop, propUTF8 );
1025
1026         require_action( ok, exit, err = kDNSServiceErr_BadParam );
1027
1028
1029
1030         // Setup the byte array
1031
1032         require_action( V_VT( value ) == ( VT_ARRAY|VT_UI1 ), exit, err = kDNSServiceErr_Unknown );
1033
1034         psa = V_ARRAY( value );
1035
1036         require_action( psa, exit, err = kDNSServiceErr_Unknown );
1037
1038         require_action( SafeArrayGetDim( psa ) == 1, exit, err = kDNSServiceErr_Unknown );
1039
1040         byteArray.reserve( psa->rgsabound[0].cElements );
1041
1042         byteArray.assign( byteArray.capacity(), 0 );
1043
1044         elems = ( uint32_t ) byteArray.capacity();
1045
1046
1047
1048         // Call the function and package the return value in the Variant
1049
1050         err = DNSServiceGetProperty( propUTF8.c_str(), &byteArray[ 0 ], &elems );
1051
1052         require_noerr( err, exit );
1053
1054         ok = ByteArrayToVariant( &byteArray[ 0 ], elems, value );
1055
1056         require_action( ok, exit, err = kDNSSDError_Unknown );
1057
1058
1059
1060 exit:
1061
1062
1063
1064         if ( psa )
1065
1066         {
1067
1068                 SafeArrayUnaccessData( psa );
1069
1070                 psa = NULL;
1071
1072         }
1073
1074
1075
1076         return err;
1077
1078 }
1079
1080
1081
1082 STDMETHODIMP CDNSSDService::GetAddrInfo(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, BSTR hostName, IDNSSDEventManager *eventManager, IDNSSDService **service)
1083
1084 {
1085
1086         CComObject<CDNSSDService>       *       object                  = NULL;
1087
1088         DNSServiceRef                                   subord                  = NULL;
1089
1090         std::string                                             hostNameUTF8;
1091
1092         DNSServiceErrorType                             err                             = 0;
1093
1094         HRESULT                                                 hr                              = 0;
1095
1096         BOOL                                                    ok;
1097
1098
1099
1100         check( m_primary );
1101
1102
1103
1104         // Initialize
1105
1106         *service = NULL;
1107
1108
1109
1110         // Convert BSTR params to utf8
1111
1112         ok = BSTRToUTF8( hostName, hostNameUTF8 );
1113
1114         require_action( ok, exit, err = kDNSServiceErr_BadParam );
1115
1116
1117
1118         try
1119
1120         {
1121
1122                 object = new CComObject<CDNSSDService>();
1123
1124         }
1125
1126         catch ( ... )
1127
1128         {
1129
1130                 object = NULL;
1131
1132         }
1133
1134
1135
1136         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
1137
1138         object->AddRef();
1139
1140
1141
1142         subord = m_primary;
1143
1144         err = DNSServiceGetAddrInfo( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, addressFamily, hostNameUTF8.c_str(), ( DNSServiceGetAddrInfoReply ) &GetAddrInfoReply, object );
1145
1146         require_noerr( err, exit );
1147
1148
1149
1150         object->SetPrimaryRef( m_primary );
1151
1152         object->SetSubordRef( subord );
1153
1154         object->SetEventManager( eventManager );
1155
1156
1157
1158         *service = object;
1159
1160
1161
1162 exit:
1163
1164
1165
1166         if ( err && object )
1167
1168         {
1169
1170                 object->Release();
1171
1172         }
1173
1174
1175
1176         return err;
1177
1178 }
1179
1180
1181
1182
1183
1184 STDMETHODIMP CDNSSDService::NATPortMappingCreate(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, DNSSDProtocol protocol, USHORT internalPort, USHORT externalPort, ULONG ttl, IDNSSDEventManager *eventManager, IDNSSDService **service)
1185
1186 {
1187
1188         CComObject<CDNSSDService>       *       object                  = NULL;
1189
1190         DNSServiceRef                                   subord                  = NULL;
1191
1192         DNSServiceProtocol                              prot                    = 0;
1193
1194         DNSServiceErrorType                             err                             = 0;
1195
1196         HRESULT                                                 hr                              = 0;
1197
1198
1199
1200         check( m_primary );
1201
1202
1203
1204         // Initialize
1205
1206         *service = NULL;
1207
1208
1209
1210         try
1211
1212         {
1213
1214                 object = new CComObject<CDNSSDService>();
1215
1216         }
1217
1218         catch ( ... )
1219
1220         {
1221
1222                 object = NULL;
1223
1224         }
1225
1226
1227
1228         require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
1229
1230         object->AddRef();
1231
1232
1233
1234         prot = ( addressFamily | protocol );
1235
1236
1237
1238         subord = m_primary;
1239
1240         err = DNSServiceNATPortMappingCreate( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, prot, htons( internalPort ), htons( externalPort ), ttl, ( DNSServiceNATPortMappingReply ) &NATPortMappingReply, object );
1241
1242         require_noerr( err, exit );
1243
1244
1245
1246         object->SetPrimaryRef( m_primary );
1247
1248         object->SetSubordRef( subord );
1249
1250         object->SetEventManager( eventManager );
1251
1252
1253
1254         *service = object;
1255
1256
1257
1258 exit:
1259
1260
1261
1262         if ( err && object )
1263
1264         {
1265
1266                 object->Release();
1267
1268         }
1269
1270
1271
1272         return err;
1273
1274 }
1275
1276
1277
1278
1279
1280 STDMETHODIMP CDNSSDService::Stop(void)
1281
1282 {
1283
1284         if ( !m_stopped )
1285
1286         {
1287
1288                 m_stopped = TRUE;
1289
1290
1291
1292                 dlog( kDebugLevelTrace, "Stop()\n" );
1293
1294
1295
1296                 if ( m_isPrimary && m_primary )
1297
1298                 {
1299
1300                         SocketMap::iterator it;
1301
1302
1303
1304                         if ( m_hiddenWindow )
1305
1306                         {
1307
1308                                 WSAAsyncSelect( DNSServiceRefSockFD( m_primary ), m_hiddenWindow, 0, 0 );
1309
1310                         }
1311
1312
1313
1314                         it = m_socketMap.find( DNSServiceRefSockFD( m_primary ) );
1315
1316
1317
1318                         if ( it != m_socketMap.end() )
1319
1320                         {
1321
1322                                 m_socketMap.erase( it );
1323
1324                         }
1325
1326
1327
1328                         DNSServiceRefDeallocate( m_primary );
1329
1330                         m_primary = NULL;
1331
1332                 }
1333
1334                 else if ( m_subord )
1335
1336                 {
1337
1338                         DNSServiceRefDeallocate( m_subord );
1339
1340                         m_subord = NULL;
1341
1342                 }
1343
1344
1345
1346                 if ( m_eventManager != NULL )
1347
1348                 {
1349
1350                         m_eventManager->Release();
1351
1352                         m_eventManager = NULL;
1353
1354                 }
1355
1356         }
1357
1358
1359
1360         return S_OK;
1361
1362 }
1363
1364
1365
1366
1367
1368 void DNSSD_API
1369 CDNSSDService::DomainEnumReply
1370     (
1371     DNSServiceRef                       sdRef,
1372     DNSServiceFlags                     flags,
1373     uint32_t                            ifIndex,
1374     DNSServiceErrorType                 errorCode,
1375     const char                          *replyDomainUTF8,
1376     void                                *context
1377     )
1378
1379 {
1380
1381         CComObject<CDNSSDService>       * service               = NULL;
1382
1383         CDNSSDEventManager                      * eventManager  = NULL;
1384
1385         int err = 0;
1386
1387
1388
1389         service = ( CComObject< CDNSSDService>* ) context;
1390
1391         require_action( service, exit, err = kDNSServiceErr_Unknown );
1392
1393
1394
1395         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1396
1397         {
1398
1399                 CComBSTR replyDomain;
1400
1401                 BOOL ok;
1402
1403
1404
1405                 ok = UTF8ToBSTR( replyDomainUTF8, replyDomain );
1406
1407                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1408
1409
1410
1411                 if ( flags & kDNSServiceFlagsAdd )
1412
1413                 {
1414
1415                         eventManager->Fire_DomainFound( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );
1416
1417                 }
1418
1419                 else
1420
1421                 {
1422
1423                         eventManager->Fire_DomainLost( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );
1424
1425                 }
1426
1427         }
1428
1429
1430
1431 exit:
1432
1433
1434
1435         return;
1436
1437 }
1438
1439
1440
1441
1442
1443 void DNSSD_API
1444 CDNSSDService::BrowseReply
1445                 (
1446                 DNSServiceRef                       sdRef,
1447                 DNSServiceFlags                     flags,
1448                 uint32_t                            ifIndex,
1449                 DNSServiceErrorType                 errorCode,
1450                 const char                          *serviceNameUTF8,
1451                 const char                          *regTypeUTF8,
1452                 const char                          *replyDomainUTF8,
1453                 void                                *context
1454                 )
1455
1456 {
1457
1458         CComObject<CDNSSDService>       * service               = NULL;
1459
1460         CDNSSDEventManager                      * eventManager  = NULL;
1461
1462         int err = 0;
1463
1464
1465
1466         service = ( CComObject< CDNSSDService>* ) context;
1467
1468         require_action( service, exit, err = kDNSServiceErr_Unknown );
1469
1470
1471
1472         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1473
1474         {
1475
1476                 CComBSTR        serviceName;
1477
1478                 CComBSTR        regType;
1479
1480                 CComBSTR        replyDomain;
1481
1482
1483
1484                 UTF8ToBSTR( serviceNameUTF8, serviceName );
1485
1486                 UTF8ToBSTR( regTypeUTF8, regType );
1487
1488                 UTF8ToBSTR( replyDomainUTF8, replyDomain );
1489
1490
1491
1492                 if ( flags & kDNSServiceFlagsAdd )
1493
1494                 {
1495
1496                         eventManager->Fire_ServiceFound( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );
1497
1498                 }
1499
1500                 else
1501
1502                 {
1503
1504                         eventManager->Fire_ServiceLost( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );
1505
1506                 }
1507
1508         }
1509
1510
1511
1512 exit:
1513
1514
1515
1516         return;
1517
1518 }
1519
1520
1521
1522
1523
1524 void DNSSD_API
1525
1526 CDNSSDService::ResolveReply
1527
1528                 (
1529                 DNSServiceRef                       sdRef,
1530                 DNSServiceFlags                     flags,
1531                 uint32_t                            ifIndex,
1532                 DNSServiceErrorType                 errorCode,
1533                 const char                          *fullNameUTF8,
1534                 const char                          *hostNameUTF8,
1535                 uint16_t                            port,
1536                 uint16_t                            txtLen,
1537                 const unsigned char                 *txtRecord,
1538                 void                                *context
1539
1540                 )
1541
1542 {
1543
1544         CComObject<CDNSSDService>       * service               = NULL;
1545
1546         CDNSSDEventManager                      * eventManager  = NULL;
1547
1548         int err = 0;
1549
1550
1551
1552         service = ( CComObject< CDNSSDService>* ) context;
1553
1554         require_action( service, exit, err = kDNSServiceErr_Unknown );
1555
1556
1557
1558         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1559
1560         {
1561
1562                 CComBSTR                                        fullName;
1563
1564                 CComBSTR                                        hostName;
1565
1566                 CComBSTR                                        regType;
1567
1568                 CComBSTR                                        replyDomain;
1569
1570                 CComObject< CTXTRecord >*       record;
1571
1572                 BOOL                                            ok;
1573
1574
1575
1576                 ok = UTF8ToBSTR( fullNameUTF8, fullName );
1577
1578                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1579
1580                 ok = UTF8ToBSTR( hostNameUTF8, hostName );
1581
1582                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1583
1584
1585
1586                 try
1587
1588                 {
1589
1590                         record = new CComObject<CTXTRecord>();
1591
1592                 }
1593
1594                 catch ( ... )
1595
1596                 {
1597
1598                         record = NULL;
1599
1600                 }
1601
1602
1603
1604                 require_action( record, exit, err = kDNSServiceErr_NoMemory );
1605
1606                 record->AddRef();
1607
1608
1609
1610                 if ( txtLen > 0 )
1611
1612                 {
1613
1614                         record->SetBytes( txtRecord, txtLen );
1615
1616                 }
1617
1618
1619
1620                 eventManager->Fire_ServiceResolved( service, ( DNSSDFlags ) flags, ifIndex, fullName, hostName, ntohs( port ), record );
1621
1622         }
1623
1624
1625
1626 exit:
1627
1628
1629
1630         return;
1631
1632 }
1633
1634
1635
1636
1637
1638 void DNSSD_API
1639 CDNSSDService::RegisterReply
1640                 (
1641                 DNSServiceRef                       sdRef,
1642                 DNSServiceFlags                     flags,
1643                 DNSServiceErrorType                 errorCode,
1644                 const char                          *serviceNameUTF8,
1645                 const char                          *regTypeUTF8,
1646                 const char                          *domainUTF8,
1647                 void                                *context
1648                 )
1649
1650 {
1651
1652         CComObject<CDNSSDService>       * service               = NULL;
1653
1654         CDNSSDEventManager                      * eventManager  = NULL;
1655
1656         int err = 0;
1657
1658
1659
1660         service = ( CComObject< CDNSSDService>* ) context;
1661
1662         require_action( service, exit, err = kDNSServiceErr_Unknown );
1663
1664
1665
1666         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1667
1668         {
1669
1670                 CComBSTR                                        serviceName;
1671
1672                 CComBSTR                                        regType;
1673
1674                 CComBSTR                                        domain;
1675
1676                 BOOL                                            ok;
1677
1678
1679
1680                 ok = UTF8ToBSTR( serviceNameUTF8, serviceName );
1681
1682                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1683
1684                 ok = UTF8ToBSTR( regTypeUTF8, regType );
1685
1686                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1687
1688                 ok = UTF8ToBSTR( domainUTF8, domain );
1689
1690                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1691
1692
1693
1694                 eventManager->Fire_ServiceRegistered( service, ( DNSSDFlags ) flags, serviceName, regType, domain );
1695
1696         }
1697
1698
1699
1700 exit:
1701
1702
1703
1704         return;
1705
1706 }
1707
1708
1709
1710
1711
1712 void DNSSD_API
1713 CDNSSDService::QueryRecordReply
1714                 (
1715                 DNSServiceRef                       sdRef,
1716                 DNSServiceFlags                     flags,
1717                 uint32_t                            ifIndex,
1718                 DNSServiceErrorType                 errorCode,
1719                 const char                          *fullNameUTF8,
1720                 uint16_t                            rrtype,
1721                 uint16_t                            rrclass,
1722                 uint16_t                            rdlen,
1723                 const void                          *rdata,
1724                 uint32_t                            ttl,
1725                 void                                *context
1726                 )
1727
1728 {
1729
1730         CComObject<CDNSSDService>       * service               = NULL;
1731
1732         CDNSSDEventManager                      * eventManager  = NULL;
1733
1734         int err = 0;
1735
1736
1737
1738         service = ( CComObject< CDNSSDService>* ) context;
1739
1740         require_action( service, exit, err = kDNSServiceErr_Unknown );
1741
1742
1743
1744         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1745
1746         {
1747
1748                 CComBSTR        fullName;
1749
1750                 VARIANT         var;
1751
1752                 BOOL            ok;
1753
1754
1755
1756                 ok = UTF8ToBSTR( fullNameUTF8, fullName );
1757
1758                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1759
1760                 ok = ByteArrayToVariant( rdata, rdlen, &var );
1761
1762                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1763
1764
1765
1766                 eventManager->Fire_QueryRecordAnswered( service, ( DNSSDFlags ) flags, ifIndex, fullName, ( DNSSDRRType ) rrtype, ( DNSSDRRClass ) rrclass, var, ttl );
1767
1768         }
1769
1770
1771
1772 exit:
1773
1774
1775
1776         return;
1777
1778 }
1779
1780
1781
1782
1783
1784 void DNSSD_API
1785 CDNSSDService::GetAddrInfoReply
1786                 (
1787                 DNSServiceRef                    sdRef,
1788                 DNSServiceFlags                  flags,
1789                 uint32_t                         ifIndex,
1790                 DNSServiceErrorType              errorCode,
1791                 const char                       *hostNameUTF8,
1792                 const struct sockaddr            *rawAddress,
1793                 uint32_t                         ttl,
1794                 void                             *context
1795                 )
1796
1797 {
1798
1799         CComObject<CDNSSDService>       * service               = NULL;
1800
1801         CDNSSDEventManager                      * eventManager  = NULL;
1802
1803         int err = 0;
1804
1805
1806
1807         service = ( CComObject< CDNSSDService>* ) context;
1808
1809         require_action( service, exit, err = kDNSServiceErr_Unknown );
1810
1811
1812
1813         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1814
1815         {
1816
1817                 CComBSTR                        hostName;
1818
1819                 DWORD                           sockaddrLen;
1820
1821                 DNSSDAddressFamily      addressFamily;
1822
1823                 char                            addressUTF8[INET6_ADDRSTRLEN];
1824
1825                 DWORD                           addressLen = sizeof( addressUTF8 );
1826
1827                 CComBSTR                        address;
1828
1829                 BOOL                            ok;
1830
1831
1832
1833                 ok = UTF8ToBSTR( hostNameUTF8, hostName );
1834
1835                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1836
1837
1838
1839                 switch ( rawAddress->sa_family )
1840
1841                 {
1842
1843                         case AF_INET:
1844
1845                         {
1846
1847                                 addressFamily   = kDNSSDAddressFamily_IPv4;
1848
1849                                 sockaddrLen             = sizeof( sockaddr_in );
1850
1851                         }
1852
1853                         break;
1854
1855
1856
1857                         case AF_INET6:
1858
1859                         {
1860
1861                                 addressFamily   = kDNSSDAddressFamily_IPv6;
1862
1863                                 sockaddrLen             = sizeof( sockaddr_in6 );
1864
1865                         }
1866
1867                         break;
1868
1869                 }
1870
1871
1872
1873                 err = WSAAddressToStringA( ( LPSOCKADDR ) rawAddress, sockaddrLen, NULL, addressUTF8, &addressLen );
1874
1875                 require_noerr( err, exit );
1876
1877                 ok = UTF8ToBSTR( addressUTF8, address );
1878
1879                 require_action( ok, exit, err = kDNSServiceErr_Unknown );
1880
1881
1882
1883                 eventManager->Fire_AddressFound( service, ( DNSSDFlags ) flags, ifIndex, hostName, addressFamily, address, ttl );
1884
1885         }
1886
1887
1888
1889 exit:
1890
1891
1892
1893         return;
1894
1895 }
1896
1897
1898
1899
1900
1901 void DNSSD_API
1902 CDNSSDService::NATPortMappingReply
1903     (
1904     DNSServiceRef                    sdRef,
1905     DNSServiceFlags                  flags,
1906     uint32_t                         ifIndex,
1907     DNSServiceErrorType              errorCode,
1908     uint32_t                         externalAddress,   /* four byte IPv4 address in network byte order */
1909     DNSServiceProtocol               protocol,
1910     uint16_t                         internalPort,
1911     uint16_t                         externalPort,      /* may be different than the requested port     */
1912     uint32_t                         ttl,               /* may be different than the requested ttl      */
1913     void                             *context
1914     )
1915
1916 {
1917
1918         CComObject<CDNSSDService>       * service               = NULL;
1919
1920         CDNSSDEventManager                      * eventManager  = NULL;
1921
1922         int err = 0;
1923
1924
1925
1926         service = ( CComObject< CDNSSDService>* ) context;
1927
1928         require_action( service, exit, err = kDNSServiceErr_Unknown );
1929
1930
1931
1932         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1933
1934         {
1935
1936                 eventManager->Fire_MappingCreated( service, ( DNSSDFlags ) flags, ifIndex, externalAddress, ( DNSSDAddressFamily ) ( protocol & 0x8 ), ( DNSSDProtocol ) ( protocol & 0x80 ), ntohs( internalPort ), ntohs( externalPort ), ttl  );
1937
1938         }
1939
1940
1941
1942 exit:
1943
1944
1945
1946         return;
1947
1948 }
1949
1950
1951
1952
1953
1954 void DNSSD_API
1955 CDNSSDService::RegisterRecordReply
1956                 (
1957                 DNSServiceRef           sdRef,
1958                 DNSRecordRef            RecordRef,
1959                 DNSServiceFlags         flags,
1960                 DNSServiceErrorType     errorCode,
1961                 void                            *context
1962                 )
1963
1964 {
1965
1966         CComObject<CDNSSDRecord>        * record                = NULL;
1967
1968         CDNSSDService                           * service               = NULL;
1969
1970         CDNSSDEventManager                      * eventManager  = NULL;
1971
1972         int err = 0;
1973
1974
1975
1976         record = ( CComObject< CDNSSDRecord >* ) context;
1977
1978         require_action( record, exit, err = kDNSServiceErr_Unknown );
1979
1980         service = record->GetServiceObject();
1981
1982         require_action( service, exit, err = kDNSServiceErr_Unknown );
1983
1984
1985
1986         if ( service->ShouldHandleReply( errorCode, eventManager ) )
1987
1988         {
1989
1990                 eventManager->Fire_RecordRegistered( record, ( DNSSDFlags ) flags );
1991
1992         }
1993
1994
1995
1996 exit:
1997
1998
1999
2000         return;
2001
2002 }
2003
2004
2005
2006
2007
2008 BOOL
2009
2010 CDNSSDService::ShouldHandleReply( DNSServiceErrorType errorCode, CDNSSDEventManager *& eventManager )
2011
2012 {
2013
2014         BOOL ok = FALSE;
2015
2016
2017
2018         if ( !this->Stopped() )
2019
2020         {
2021
2022                 eventManager = this->GetEventManager();
2023
2024                 require_action( eventManager, exit, ok = FALSE );
2025
2026
2027
2028                 if ( !errorCode )
2029
2030                 {
2031
2032                         ok = TRUE;
2033
2034                 }
2035
2036                 else
2037
2038                 {
2039
2040                         eventManager->Fire_OperationFailed( this, ( DNSSDError ) errorCode );
2041
2042                 }
2043
2044         }
2045
2046
2047
2048 exit:
2049
2050
2051
2052         return ok;
2053
2054 }
2055
2056
2057
2058
2059
2060 LRESULT CALLBACK
2061
2062 CDNSSDService::WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
2063
2064 {
2065
2066         if ( msg == WM_SOCKET )
2067
2068         {
2069
2070                 SocketMap::iterator it;
2071
2072
2073
2074                 it = m_socketMap.find( ( SOCKET ) wParam );
2075
2076                 check( it != m_socketMap.end() );
2077
2078
2079
2080                 if ( it != m_socketMap.end() )
2081
2082                 {
2083
2084                         DNSServiceProcessResult( it->second->m_primary );
2085
2086                 }
2087
2088         }
2089
2090
2091
2092         return DefWindowProc(hWnd, msg, wParam, lParam);;
2093
2094 }
2095