]> git.saurik.com Git - apple/mdnsresponder.git/blob - mDNSWindows/DLL.NET/dnssd_NET.cpp
projects / apple / mdnsresponder.git / blob
? search:


b30699e8b22b1ebb4eafe72c2e5e8f153323c394
[apple/mdnsresponder.git] / mDNSWindows / DLL.NET / dnssd_NET.cpp
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2003-2004 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 Change History (most recent first):
18
19 $Log: dnssd_NET.cpp,v $
20 Revision 1.11 2009/03/30 20:19:05 herscher
21 <rdar://problem/5925472> Current Bonjour code does not compile on Windows
22 <rdar://problem/5187308> Move build train to Visual Studio 2005
23
24 Revision 1.10 2006/08/14 23:25:43 cheshire
25 Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0
26
27 Revision 1.9 2004/09/16 18:17:13 shersche
28 Use background threads, cleanup to parameter names.
29 Submitted by: prepin@gmail.com
30
31 Revision 1.8 2004/09/13 19:35:58 shersche
32 <rdar://problem/3798941> Add Apple.DNSSD namespace to MC++ wrapper class
33 <rdar://problem/3798950> Change all instances of unsigned short to int
34 Bug #: 3798941, 3798950
35
36 Revision 1.7 2004/09/11 00:36:40 shersche
37 <rdar://problem/3786226> Modified .NET shim code to use host byte order for ports in APIs and callbacks
38 Bug #: 3786226
39
40 Revision 1.6 2004/09/02 21:20:56 cheshire
41 <rdar://problem/3774871> DLL.NET crashes on null record
42
43 Revision 1.5 2004/07/27 07:12:56 shersche
44 make TextRecord an instantiable class object
45
46 Revision 1.4 2004/07/26 06:19:05 shersche
47 Treat byte arrays of zero-length as null arrays
48
49 Revision 1.3 2004/07/19 16:08:56 shersche
50 fix problems in UTF8/Unicode string translations
51
52 Revision 1.2 2004/07/19 07:48:34 shersche
53 fix bug in DNSService.Register when passing in NULL text record, add TextRecord APIs
54
55 Revision 1.1 2004/06/26 04:01:22 shersche
56 Initial revision
57
58
59 */
60
61 // This is the main DLL file.
62
63 #include "stdafx.h"
64
65 #include "dnssd_NET.h"
66 #include "DebugServices.h"
67 #include "PString.h"
68
69
70 using namespace System::Net::Sockets;
71 using namespace System::Diagnostics;
72 using namespace Apple;
73 using namespace Apple::DNSSD;
74
75
76 //===========================================================================================================================
77 // Constants
78 //===========================================================================================================================
79
80 #define DEBUG_NAME "[dnssd.NET] "
81
82 //
83 // ConvertToString
84 //
85 static String*
86 ConvertToString(const char * utf8String)
87 {
88 return __gc new String(utf8String, 0, strlen(utf8String), __gc new UTF8Encoding(true, true));
89 }
90
91
92 //
93 // class ServiceRef
94 //
95 // ServiceRef serves as the base class for all DNSService operations.
96 //
97 // It manages the DNSServiceRef, and implements processing the
98 // result
99 //
100 ServiceRef::ServiceRef(Object * callback)
101 :
102 m_bDisposed(false),
103 m_callback(callback),
104 m_thread(NULL)
105 {
106 m_impl = new ServiceRefImpl(this);
107 }
108
109
110 ServiceRef::~ServiceRef()
111 {
112 }
113
114
115 //
116 // StartThread
117 //
118 // Starts the main processing thread
119 //
120 void
121 ServiceRef::StartThread()
122 {
123 check( m_impl != NULL );
124
125 m_impl->SetupEvents();
126
127 m_thread = new Thread(new ThreadStart(this, &Apple::DNSSD::ServiceRef::ProcessingThread));
128 m_thread->Name = S"DNSService Thread";
129 m_thread->IsBackground = true;
130
131 m_thread->Start();
132 }
133
134
135 //
136 // ProcessingThread
137 //
138 // The Thread class can only invoke methods in MC++ types. So we
139 // make a ProcessingThread method that forwards to the impl
140 //
141 void
142 ServiceRef::ProcessingThread()
143 {
144 m_impl->ProcessingThread();
145 }
146
147
148 //
149 // Dispose
150 //
151 // Calls impl-Dispose(). This ultimately will call DNSServiceRefDeallocate()
152 //
153 void
154 ServiceRef::Dispose()
155 {
156 check(m_impl != NULL);
157 check(m_bDisposed == false);
158
159 if (!m_bDisposed)
160 {
161 m_bDisposed = true;
162
163 //
164 // Call Dispose. This won't call DNSServiceRefDeallocate()
165 // necessarily. It depends on what thread this is being
166 // called in.
167 //
168 m_impl->Dispose();
169 m_impl = NULL;
170
171 m_thread = NULL;
172
173 GC::SuppressFinalize(this);
174 }
175 }
176
177
178 //
179 // EnumerateDomainsDispatch
180 //
181 // Dispatch a reply to the delegate.
182 //
183 void
184 ServiceRef::EnumerateDomainsDispatch
185 (
186 ServiceFlags flags,
187 int interfaceIndex,
188 ErrorCode errorCode,
189 String * replyDomain
190 )
191 {
192 if ((m_callback != NULL) && (m_impl != NULL))
193 {
194 DNSService::EnumerateDomainsReply * OnEnumerateDomainsReply = static_cast<DNSService::EnumerateDomainsReply*>(m_callback);
195 OnEnumerateDomainsReply(this, flags, interfaceIndex, errorCode, replyDomain);
196 }
197 }
198
199
200 //
201 // RegisterDispatch
202 //
203 // Dispatch a reply to the delegate.
204 //
205 void
206 ServiceRef::RegisterDispatch
207 (
208 ServiceFlags flags,
209 ErrorCode errorCode,
210 String * name,
211 String * regtype,
212 String * domain
213 )
214 {
215 if ((m_callback != NULL) && (m_impl != NULL))
216 {
217 DNSService::RegisterReply * OnRegisterReply = static_cast<DNSService::RegisterReply*>(m_callback);
218 OnRegisterReply(this, flags, errorCode, name, regtype, domain);
219 }
220 }
221
222
223 //
224 // BrowseDispatch
225 //
226 // Dispatch a reply to the delegate.
227 //
228 void
229 ServiceRef::BrowseDispatch
230 (
231 ServiceFlags flags,
232 int interfaceIndex,
233 ErrorCode errorCode,
234 String * serviceName,
235 String * regtype,
236 String * replyDomain
237 )
238 {
239 if ((m_callback != NULL) && (m_impl != NULL))
240 {
241 DNSService::BrowseReply * OnBrowseReply = static_cast<DNSService::BrowseReply*>(m_callback);
242 OnBrowseReply(this, flags, interfaceIndex, errorCode, serviceName, regtype, replyDomain);
243 }
244 }
245
246
247 //
248 // ResolveDispatch
249 //
250 // Dispatch a reply to the delegate.
251 //
252 void
253 ServiceRef::ResolveDispatch
254 (
255 ServiceFlags flags,
256 int interfaceIndex,
257 ErrorCode errorCode,
258 String * fullname,
259 String * hosttarget,
260 int port,
261 Byte txtRecord[]
262 )
263 {
264 if ((m_callback != NULL) && (m_impl != NULL))
265 {
266 DNSService::ResolveReply * OnResolveReply = static_cast<DNSService::ResolveReply*>(m_callback);
267 OnResolveReply(this, flags, interfaceIndex, errorCode, fullname, hosttarget, port, txtRecord);
268 }
269 }
270
271
272 //
273 // RegisterRecordDispatch
274 //
275 // Dispatch a reply to the delegate.
276 //
277 void
278 ServiceRef::RegisterRecordDispatch
279 (
280 ServiceFlags flags,
281 ErrorCode errorCode,
282 RecordRef * record
283 )
284 {
285 if ((m_callback != NULL) && (m_impl != NULL))
286 {
287 DNSService::RegisterRecordReply * OnRegisterRecordReply = static_cast<DNSService::RegisterRecordReply*>(m_callback);
288 OnRegisterRecordReply(this, flags, errorCode, record);
289 }
290 }
291
292
293 //
294 // QueryRecordDispatch
295 //
296 // Dispatch a reply to the delegate.
297 //
298 void
299 ServiceRef::QueryRecordDispatch
300 (
301 ServiceFlags flags,
302 int interfaceIndex,
303 ErrorCode errorCode,
304 String * fullname,
305 int rrtype,
306 int rrclass,
307 Byte rdata[],
308 int ttl
309 )
310 {
311 if ((m_callback != NULL) && (m_impl != NULL))
312 {
313 DNSService::QueryRecordReply * OnQueryRecordReply = static_cast<DNSService::QueryRecordReply*>(m_callback);
314 OnQueryRecordReply(this, flags, interfaceIndex, errorCode, fullname, rrtype, rrclass, rdata, ttl);
315 }
316 }
317
318
319 //
320 // ServiceRefImpl::ServiceRefImpl()
321 //
322 // Constructs a new ServiceRefImpl. We save the pointer to our enclosing
323 // class in a gcroot handle. This satisfies the garbage collector as
324 // the outer class is a managed type
325 //
326 ServiceRef::ServiceRefImpl::ServiceRefImpl(ServiceRef * outer)
327 :
328 m_socketEvent(NULL),
329 m_stopEvent(NULL),
330 m_disposed(false),
331 m_outer(outer),
332 m_ref(NULL)
333 {
334 m_threadId = GetCurrentThreadId();
335 }
336
337
338 //
339 // ServiceRefImpl::~ServiceRefImpl()
340 //
341 // Deallocate all resources associated with the ServiceRefImpl
342 //
343 ServiceRef::ServiceRefImpl::~ServiceRefImpl()
344 {
345 if (m_socketEvent != NULL)
346 {
347 CloseHandle(m_socketEvent);
348 m_socketEvent = NULL;
349 }
350
351 if (m_stopEvent != NULL)
352 {
353 CloseHandle(m_stopEvent);
354 m_stopEvent = NULL;
355 }
356
357 if (m_ref != NULL)
358 {
359 DNSServiceRefDeallocate(m_ref);
360 m_ref = NULL;
361 }
362 }
363
364
365 //
366 // ServiceRefImpl::SetupEvents()
367 //
368 // Setup the events necessary to manage multi-threaded dispatch
369 // of DNSService Events
370 //
371 void
372 ServiceRef::ServiceRefImpl::SetupEvents()
373 {
374 check(m_ref != NULL);
375
376 m_socket = (SOCKET) DNSServiceRefSockFD(m_ref);
377 check(m_socket != INVALID_SOCKET);
378
379 m_socketEvent = CreateEvent(NULL, 0, 0, NULL);
380
381 if (m_socketEvent == NULL)
382 {
383 throw new DNSServiceException(Unknown);
384 }
385
386 int err = WSAEventSelect(m_socket, m_socketEvent, FD_READ|FD_CLOSE);
387
388 if (err != 0)
389 {
390 throw new DNSServiceException(Unknown);
391 }
392
393 m_stopEvent = CreateEvent(NULL, 0, 0, NULL);
394
395 if (m_stopEvent == NULL)
396 {
397 throw new DNSServiceException(Unknown);
398 }
399 }
400
401
402 //
403 // ServiceRefImpl::ProcessingThread()
404 //
405 // Wait for socket events on the DNSServiceRefSockFD(). Also wait
406 // for stop events
407 //
408 void
409 ServiceRef::ServiceRefImpl::ProcessingThread()
410 {
411 check( m_socketEvent != NULL );
412 check( m_stopEvent != NULL );
413 check( m_ref != NULL );
414
415 HANDLE handles[2];
416
417 handles[0] = m_socketEvent;
418 handles[1] = m_stopEvent;
419
420 while (m_disposed == false)
421 {
422 int ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
423
424 //
425 // it's a socket event
426 //
427 if (ret == WAIT_OBJECT_0)
428 {
429 DNSServiceProcessResult(m_ref);
430 }
431 //
432 // else it's a stop event
433 //
434 else if (ret == WAIT_OBJECT_0 + 1)
435 {
436 break;
437 }
438 else
439 {
440 //
441 // unexpected wait result
442 //
443 dlog( kDebugLevelWarning, DEBUG_NAME "%s: unexpected wait result (result=0x%08X)\n", __ROUTINE__, ret );
444 }
445 }
446
447 delete this;
448 }
449
450
451 //
452 // ServiceRefImpl::Dispose()
453 //
454 // Calls DNSServiceRefDeallocate()
455 //
456 void
457 ServiceRef::ServiceRefImpl::Dispose()
458 {
459 OSStatus err;
460 BOOL ok;
461
462 check(m_disposed == false);
463
464 m_disposed = true;
465
466 ok = SetEvent(m_stopEvent);
467 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr );
468 require_noerr( err, exit );
469
470 exit:
471
472 return;
473 }
474
475
476 //
477 // ServiceRefImpl::EnumerateDomainsCallback()
478 //
479 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
480 //
481 void DNSSD_API
482 ServiceRef::ServiceRefImpl::EnumerateDomainsCallback
483 (
484 DNSServiceRef sdRef,
485 DNSServiceFlags flags,
486 uint32_t interfaceIndex,
487 DNSServiceErrorType errorCode,
488 const char * replyDomain,
489 void * context
490 )
491 {
492 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
493
494 check( self != NULL );
495 check( self->m_outer != NULL );
496
497 if (self->m_disposed == false)
498 {
499 self->m_outer->EnumerateDomainsDispatch((ServiceFlags) flags, interfaceIndex, (ErrorCode) errorCode, ConvertToString(replyDomain));
500 }
501 }
502
503
504 //
505 // ServiceRefImpl::RegisterCallback()
506 //
507 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
508 //
509 void DNSSD_API
510 ServiceRef::ServiceRefImpl::RegisterCallback
511 (
512 DNSServiceRef sdRef,
513 DNSServiceFlags flags,
514 DNSServiceErrorType errorCode,
515 const char * name,
516 const char * regtype,
517 const char * domain,
518 void * context
519 )
520 {
521 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
522
523 check( self != NULL );
524 check( self->m_outer != NULL );
525
526 if (self->m_disposed == false)
527 {
528 self->m_outer->RegisterDispatch((ServiceFlags) flags, (ErrorCode) errorCode, ConvertToString(name), ConvertToString(regtype), ConvertToString(domain));
529 }
530 }
531
532
533 //
534 // ServiceRefImpl::BrowseCallback()
535 //
536 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
537 //
538 void DNSSD_API
539 ServiceRef::ServiceRefImpl::BrowseCallback
540 (
541 DNSServiceRef sdRef,
542 DNSServiceFlags flags,
543 uint32_t interfaceIndex,
544 DNSServiceErrorType errorCode,
545 const char * serviceName,
546 const char * regtype,
547 const char * replyDomain,
548 void * context
549 )
550 {
551 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
552
553 check( self != NULL );
554 check( self->m_outer != NULL );
555
556 if (self->m_disposed == false)
557 {
558 self->m_outer->BrowseDispatch((ServiceFlags) flags, interfaceIndex, (ErrorCode) errorCode, ConvertToString(serviceName), ConvertToString(regtype), ConvertToString(replyDomain));
559 }
560 }
561
562
563 //
564 // ServiceRefImpl::ResolveCallback()
565 //
566 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
567 //
568 void DNSSD_API
569 ServiceRef::ServiceRefImpl::ResolveCallback
570 (
571 DNSServiceRef sdRef,
572 DNSServiceFlags flags,
573 uint32_t interfaceIndex,
574 DNSServiceErrorType errorCode,
575 const char * fullname,
576 const char * hosttarget,
577 uint16_t notAnIntPort,
578 uint16_t txtLen,
579 const char * txtRecord,
580 void * context
581 )
582 {
583 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
584
585 check( self != NULL );
586 check( self->m_outer != NULL );
587
588 if (self->m_disposed == false)
589 {
590 Byte txtRecordBytes[];
591
592 txtRecordBytes = NULL;
593
594 if (txtLen > 0)
595 {
596 //
597 // copy raw memory into managed byte array
598 //
599 txtRecordBytes = new Byte[txtLen];
600 Byte __pin * p = &txtRecordBytes[0];
601 memcpy(p, txtRecord, txtLen);
602 }
603
604 self->m_outer->ResolveDispatch((ServiceFlags) flags, interfaceIndex, (ErrorCode) errorCode, ConvertToString(fullname), ConvertToString(hosttarget), ntohs(notAnIntPort), txtRecordBytes);
605 }
606 }
607
608
609 //
610 // ServiceRefImpl::RegisterRecordCallback()
611 //
612 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
613 //
614 void DNSSD_API
615 ServiceRef::ServiceRefImpl::RegisterRecordCallback
616 (
617 DNSServiceRef sdRef,
618 DNSRecordRef rrRef,
619 DNSServiceFlags flags,
620 DNSServiceErrorType errorCode,
621 void * context
622 )
623 {
624 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
625
626 check( self != NULL );
627 check( self->m_outer != NULL );
628
629 if (self->m_disposed == false)
630 {
631 RecordRef * record = NULL;
632
633 if (errorCode == 0)
634 {
635 record = new RecordRef;
636
637 record->m_impl->m_ref = rrRef;
638 }
639
640 self->m_outer->RegisterRecordDispatch((ServiceFlags) flags, (ErrorCode) errorCode, record);
641 }
642 }
643
644
645 //
646 // ServiceRefImpl::QueryRecordCallback()
647 //
648 // This is the callback from dnssd.dll. We pass this up to our outer, managed type
649 //
650 void DNSSD_API
651 ServiceRef::ServiceRefImpl::QueryRecordCallback
652 (
653 DNSServiceRef DNSServiceRef,
654 DNSServiceFlags flags,
655 uint32_t interfaceIndex,
656 DNSServiceErrorType errorCode,
657 const char * fullname,
658 uint16_t rrtype,
659 uint16_t rrclass,
660 uint16_t rdlen,
661 const void * rdata,
662 uint32_t ttl,
663 void * context
664 )
665 {
666 ServiceRef::ServiceRefImpl * self = static_cast<ServiceRef::ServiceRefImpl*>(context);
667
668 check( self != NULL );
669 check( self->m_outer != NULL );
670
671 if (self->m_disposed == false)
672 {
673 Byte rdataBytes[];
674
675 if (rdlen)
676 {
677 rdataBytes = new Byte[rdlen];
678 Byte __pin * p = &rdataBytes[0];
679 memcpy(p, rdata, rdlen);
680 }
681
682 self->m_outer->QueryRecordDispatch((ServiceFlags) flags, (int) interfaceIndex, (ErrorCode) errorCode, ConvertToString(fullname), rrtype, rrclass, rdataBytes, ttl);
683 }
684 }
685
686
687 /*
688 * EnumerateDomains()
689 *
690 * This maps to DNSServiceEnumerateDomains(). Returns an
691 * initialized ServiceRef on success, throws an exception
692 * on failure.
693 */
694 ServiceRef*
695 DNSService::EnumerateDomains
696 (
697 int flags,
698 int interfaceIndex,
699 EnumerateDomainsReply * callback
700 )
701 {
702 ServiceRef * sdRef = new ServiceRef(callback);
703 int err;
704
705 err = DNSServiceEnumerateDomains(&sdRef->m_impl->m_ref, flags, interfaceIndex, ServiceRef::ServiceRefImpl::EnumerateDomainsCallback, sdRef->m_impl);
706
707 if (err != 0)
708 {
709 throw new DNSServiceException(err);
710 }
711
712 sdRef->StartThread();
713
714 return sdRef;
715 }
716
717
718 /*
719 * Register()
720 *
721 * This maps to DNSServiceRegister(). Returns an
722 * initialized ServiceRef on success, throws an exception
723 * on failure.
724 */
725 ServiceRef*
726 DNSService::Register
727 (
728 int flags,
729 int interfaceIndex,
730 String * name,
731 String * regtype,
732 String * domain,
733 String * host,
734 int port,
735 Byte txtRecord[],
736 RegisterReply * callback
737 )
738 {
739 ServiceRef * sdRef = new ServiceRef(callback);
740 PString * pName = new PString(name);
741 PString * pType = new PString(regtype);
742 PString * pDomain = new PString(domain);
743 PString * pHost = new PString(host);
744 int len = 0;
745 Byte __pin * p = NULL;
746 void * v = NULL;
747
748 if ((txtRecord != NULL) && (txtRecord->Length > 0))
749 {
750 len = txtRecord->Length;
751 p = &txtRecord[0];
752 v = (void*) p;
753 }
754
755 int err = DNSServiceRegister(&sdRef->m_impl->m_ref, flags, interfaceIndex, pName->c_str(), pType->c_str(), pDomain->c_str(), pHost->c_str(), htons(port), len, v, ServiceRef::ServiceRefImpl::RegisterCallback, sdRef->m_impl );
756
757 if (err != 0)
758 {
759 throw new DNSServiceException(err);
760 }
761
762 sdRef->StartThread();
763
764 return sdRef;
765 }
766
767
768 /*
769 * AddRecord()
770 *
771 * This maps to DNSServiceAddRecord(). Returns an
772 * initialized ServiceRef on success, throws an exception
773 * on failure.
774 */
775 RecordRef*
776 DNSService::AddRecord
777 (
778 ServiceRef * sdRef,
779 int flags,
780 int rrtype,
781 Byte rdata[],
782 int ttl
783 )
784 {
785 int len = 0;
786 Byte __pin * p = NULL;
787 void * v = NULL;
788
789 if ((rdata != NULL) && (rdata->Length > 0))
790 {
791 len = rdata->Length;
792 p = &rdata[0];
793 v = (void*) p;
794 }
795
796 RecordRef * record = new RecordRef;
797
798 int err = DNSServiceAddRecord(sdRef->m_impl->m_ref, &record->m_impl->m_ref, flags, rrtype, len, v, ttl);
799
800 if (err != 0)
801 {
802 throw new DNSServiceException(err);
803 }
804
805 return record;
806 }
807
808
809 /*
810 * UpdateRecord()
811 *
812 * This maps to DNSServiceUpdateRecord(). Returns an
813 * initialized ServiceRef on success, throws an exception
814 * on failure.
815 */
816 void
817 DNSService::UpdateRecord
818 (
819 ServiceRef * sdRef,
820 RecordRef * record,
821 int flags,
822 Byte rdata[],
823 int ttl
824 )
825 {
826 int len = 0;
827 Byte __pin * p = NULL;
828 void * v = NULL;
829
830 if ((rdata != NULL) && (rdata->Length > 0))
831 {
832 len = rdata->Length;
833 p = &rdata[0];
834 v = (void*) p;
835 }
836
837 int err = DNSServiceUpdateRecord(sdRef->m_impl->m_ref, record ? record->m_impl->m_ref : NULL, flags, len, v, ttl);
838
839 if (err != 0)
840 {
841 throw new DNSServiceException(err);
842 }
843 }
844
845
846 /*
847 * RemoveRecord()
848 *
849 * This maps to DNSServiceRemoveRecord(). Returns an
850 * initialized ServiceRef on success, throws an exception
851 * on failure.
852 */
853 void
854 DNSService::RemoveRecord
855 (
856 ServiceRef * sdRef,
857 RecordRef * record,
858 int flags
859 )
860 {
861 int err = DNSServiceRemoveRecord(sdRef->m_impl->m_ref, record->m_impl->m_ref, flags);
862
863 if (err != 0)
864 {
865 throw new DNSServiceException(err);
866 }
867 }
868
869
870 /*
871 * Browse()
872 *
873 * This maps to DNSServiceBrowse(). Returns an
874 * initialized ServiceRef on success, throws an exception
875 * on failure.
876 */
877 ServiceRef*
878 DNSService::Browse
879 (
880 int flags,
881 int interfaceIndex,
882 String * regtype,
883 String * domain,
884 BrowseReply * callback
885 )
886 {
887 ServiceRef * sdRef = new ServiceRef(callback);
888 PString * pType = new PString(regtype);
889 PString * pDomain = new PString(domain);
890
891 int err = DNSServiceBrowse(&sdRef->m_impl->m_ref, flags, interfaceIndex, pType->c_str(), pDomain->c_str(),(DNSServiceBrowseReply) ServiceRef::ServiceRefImpl::BrowseCallback, sdRef->m_impl);
892
893 if (err != 0)
894 {
895 throw new DNSServiceException(err);
896 }
897
898 sdRef->StartThread();
899
900 return sdRef;
901 }
902
903
904 /*
905 * Resolve()
906 *
907 * This maps to DNSServiceResolve(). Returns an
908 * initialized ServiceRef on success, throws an exception
909 * on failure.
910 */
911 ServiceRef*
912 DNSService::Resolve
913 (
914 int flags,
915 int interfaceIndex,
916 String * name,
917 String * regtype,
918 String * domain,
919 ResolveReply * callback
920 )
921 {
922 ServiceRef * sdRef = new ServiceRef(callback);
923 PString * pName = new PString(name);
924 PString * pType = new PString(regtype);
925 PString * pDomain = new PString(domain);
926
927 int err = DNSServiceResolve(&sdRef->m_impl->m_ref, flags, interfaceIndex, pName->c_str(), pType->c_str(), pDomain->c_str(),(DNSServiceResolveReply) ServiceRef::ServiceRefImpl::ResolveCallback, sdRef->m_impl);
928
929 if (err != 0)
930 {
931 throw new DNSServiceException(err);
932 }
933
934 sdRef->StartThread();
935
936 return sdRef;
937 }
938
939
940 /*
941 * CreateConnection()
942 *
943 * This maps to DNSServiceCreateConnection(). Returns an
944 * initialized ServiceRef on success, throws an exception
945 * on failure.
946 */
947 ServiceRef*
948 DNSService::CreateConnection
949 (
950 RegisterRecordReply * callback
951 )
952 {
953 ServiceRef * sdRef = new ServiceRef(callback);
954
955 int err = DNSServiceCreateConnection(&sdRef->m_impl->m_ref);
956
957 if (err != 0)
958 {
959 throw new DNSServiceException(err);
960 }
961
962 sdRef->StartThread();
963
964 return sdRef;
965 }
966
967
968 /*
969 * RegisterRecord()
970 *
971 * This maps to DNSServiceRegisterRecord(). Returns an
972 * initialized ServiceRef on success, throws an exception
973 * on failure.
974 */
975
976 RecordRef*
977 DNSService::RegisterRecord
978 (
979 ServiceRef * sdRef,
980 ServiceFlags flags,
981 int interfaceIndex,
982 String * fullname,
983 int rrtype,
984 int rrclass,
985 Byte rdata[],
986 int ttl
987 )
988 {
989 RecordRef * record = new RecordRef;
990 int len = 0;
991 Byte __pin * p = NULL;
992 void * v = NULL;
993
994 PString * pFullname = new PString(fullname);
995
996 if ((rdata != NULL) && (rdata->Length > 0))
997 {
998 len = rdata->Length;
999 p = &rdata[0];
1000 v = (void*) p;
1001 }
1002
1003 int err = DNSServiceRegisterRecord(sdRef->m_impl->m_ref, &record->m_impl->m_ref, flags, interfaceIndex, pFullname->c_str(), rrtype, rrclass, len, v, ttl, (DNSServiceRegisterRecordReply) ServiceRef::ServiceRefImpl::RegisterRecordCallback, sdRef->m_impl);
1004
1005 if (err != 0)
1006 {
1007 throw new DNSServiceException(err);
1008 }
1009
1010 return record;
1011 }
1012
1013 /*
1014 * QueryRecord()
1015 *
1016 * This maps to DNSServiceQueryRecord(). Returns an
1017 * initialized ServiceRef on success, throws an exception
1018 * on failure.
1019 */
1020 ServiceRef*
1021 DNSService::QueryRecord
1022 (
1023 ServiceFlags flags,
1024 int interfaceIndex,
1025 String * fullname,
1026 int rrtype,
1027 int rrclass,
1028 QueryRecordReply * callback
1029 )
1030 {
1031 ServiceRef * sdRef = new ServiceRef(callback);
1032 PString * pFullname = new PString(fullname);
1033
1034 int err = DNSServiceQueryRecord(&sdRef->m_impl->m_ref, flags, interfaceIndex, pFullname->c_str(), rrtype, rrclass, (DNSServiceQueryRecordReply) ServiceRef::ServiceRefImpl::QueryRecordCallback, sdRef->m_impl);
1035
1036 if (err != 0)
1037 {
1038 throw new DNSServiceException(err);
1039 }
1040
1041 sdRef->StartThread();
1042
1043 return sdRef;
1044 }
1045
1046
1047 /*
1048 * ReconfirmRecord()
1049 *
1050 * This maps to DNSServiceReconfirmRecord(). Returns an
1051 * initialized ServiceRef on success, throws an exception
1052 * on failure.
1053 */
1054 void
1055 DNSService::ReconfirmRecord
1056 (
1057 ServiceFlags flags,
1058 int interfaceIndex,
1059 String * fullname,
1060 int rrtype,
1061 int rrclass,
1062 Byte rdata[]
1063 )
1064 {
1065 int len = 0;
1066 Byte __pin * p = NULL;
1067 void * v = NULL;
1068
1069 PString * pFullname = new PString(fullname);
1070
1071 if ((rdata != NULL) && (rdata->Length > 0))
1072 {
1073 len = rdata->Length;
1074 p = &rdata[0];
1075 v = (void*) p;
1076 }
1077
1078 DNSServiceReconfirmRecord(flags, interfaceIndex, pFullname->c_str(), rrtype, rrclass, len, v);
1079 }
1080
1081
1082 void
1083 TextRecord::SetValue
1084 (
1085 String * key,
1086 Byte value[] /* may be NULL */
1087 )
1088 {
1089 PString * pKey = new PString(key);
1090 int len = 0;
1091 Byte __pin * p = NULL;
1092 void * v = NULL;
1093 DNSServiceErrorType err;
1094
1095 if (value && (value->Length > 0))
1096 {
1097 len = value->Length;
1098 p = &value[0];
1099 v = (void*) p;
1100 }
1101
1102 err = TXTRecordSetValue(&m_impl->m_ref, pKey->c_str(), len, v);
1103
1104 if (err != 0)
1105 {
1106 throw new DNSServiceException(err);
1107 }
1108 }
1109
1110
1111 void
1112 TextRecord::RemoveValue
1113 (
1114 String * key
1115 )
1116 {
1117 PString * pKey = new PString(key);
1118 DNSServiceErrorType err;
1119
1120 err = TXTRecordRemoveValue(&m_impl->m_ref, pKey->c_str());
1121
1122 if (err != 0)
1123 {
1124 throw new DNSServiceException(err);
1125 }
1126 }
1127
1128
1129 int
1130 TextRecord::GetLength
1131 (
1132 )
1133 {
1134 return TXTRecordGetLength(&m_impl->m_ref);
1135 }
1136
1137
1138 Byte
1139 TextRecord::GetBytes
1140 (
1141 ) __gc[]
1142 {
1143 const void * noGCBytes = NULL;
1144 Byte gcBytes[] = NULL;
1145
1146 noGCBytes = TXTRecordGetBytesPtr(&m_impl->m_ref);
1147 int len = GetLength();
1148
1149 if (noGCBytes && len)
1150 {
1151 gcBytes = new Byte[len];
1152 Byte __pin * p = &gcBytes[0];
1153 memcpy(p, noGCBytes, len);
1154 }
1155
1156 return gcBytes;
1157 }
1158
1159
1160 bool
1161 TextRecord::ContainsKey
1162 (
1163 Byte txtRecord[],
1164 String * key
1165 )
1166 {
1167 PString * pKey = new PString(key);
1168 Byte __pin * p = &txtRecord[0];
1169
1170 return (TXTRecordContainsKey(txtRecord->Length, p, pKey->c_str()) > 0) ? true : false;
1171 }
1172
1173
1174 Byte
1175 TextRecord::GetValueBytes
1176 (
1177 Byte txtRecord[],
1178 String * key
1179 ) __gc[]
1180 {
1181 uint8_t valueLen;
1182 Byte ret[] = NULL;
1183 PString * pKey = new PString(key);
1184 Byte __pin * p1 = &txtRecord[0];
1185 const void * v;
1186
1187 v = TXTRecordGetValuePtr(txtRecord->Length, p1, pKey->c_str(), &valueLen);
1188
1189 if (v != NULL)
1190 {
1191 ret = new Byte[valueLen];
1192 Byte __pin * p2 = &ret[0];
1193
1194 memcpy(p2, v, valueLen);
1195 }
1196
1197 return ret;
1198 }
1199
1200
1201 int
1202 TextRecord::GetCount
1203 (
1204 Byte txtRecord[]
1205 )
1206 {
1207 Byte __pin * p = &txtRecord[0];
1208
1209 return TXTRecordGetCount(txtRecord->Length, p);
1210 }
1211
1212
1213 Byte
1214 TextRecord::GetItemAtIndex
1215 (
1216 Byte txtRecord[],
1217 int index,
1218 [Out] String ** key
1219 ) __gc[]
1220 {
1221 char keyBuf[255];
1222 uint8_t keyBufLen = 255;
1223 uint8_t valueLen;
1224 void * value;
1225 Byte ret[] = NULL;
1226 DNSServiceErrorType err;
1227 Byte __pin * p1 = &txtRecord[0];
1228
1229
1230 err = TXTRecordGetItemAtIndex(txtRecord->Length, p1, index, keyBufLen, keyBuf, &valueLen, (const void**) &value);
1231
1232 if (err != 0)
1233 {
1234 throw new DNSServiceException(err);
1235 }
1236
1237 *key = ConvertToString(keyBuf);
1238
1239 if (valueLen)
1240 {
1241 ret = new Byte[valueLen];
1242 Byte __pin * p2 = &ret[0];
1243
1244 memcpy(p2, value, valueLen);
1245 }
1246
1247 return ret;
1248 }
1249
1250
1251 //
1252 // DNSServiceException::DNSServiceException()
1253 //
1254 // Constructs an exception with an error code
1255 //
1256 DNSServiceException::DNSServiceException
1257 (
1258 int _err
1259 )
1260 :
1261 err(_err)
1262 {
1263 }
1264
1265
1266 //
1267 // This version of the constructor is useful for instances in which
1268 // an inner exception is thrown, caught, and then a new exception
1269 // is thrown in it's place
1270 //
1271 DNSServiceException::DNSServiceException
1272 (
1273 String * message,
1274 System::Exception * innerException
1275 )
1276 {
1277 }
mirror of mDNSResponder