* add option to not enable SO_REUSEADDR for multicast sockets, effectively disallow...

[catta] / avahi-sharp / AddressResolver.cs

diff --git a/avahi-sharp/AddressResolver.cs b/avahi-sharp/AddressResolver.cs
index 730645fccc74bc3462a7c9994bb4ca1f39b34376..01211aecd9cb6e20676c5efe260decfcda3369a9 100644 (file)
--- a/avahi-sharp/AddressResolver.cs
+++ b/avahi-sharp/AddressResolver.cs
@@ -1,3 +1,24 @@
+/* $Id$ */
+
+/***
+  This file is part of avahi.
+
+  avahi is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as
+  published by the Free Software Foundation; either version 2.1 of the
+  License, or (at your option) any later version.
+
+  avahi is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+  Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with avahi; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+

 using System;
 using System.Collections;
 using System.Net;
 using System;
 using System.Collections;
 using System.Net;


@@ -9,17 +30,19 @@ namespace Avahi
 
     internal delegate void AddressResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                     ResolverEvent revent, Protocol aproto, IntPtr address,
 
     internal delegate void AddressResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                     ResolverEvent revent, Protocol aproto, IntPtr address,

-                                                    IntPtr hostname, IntPtr userdata);
+                                                    IntPtr hostname, LookupResultFlags flags, IntPtr userdata);

 
     public delegate void HostAddressHandler (object o, string host, IPAddress address);
     
 
     public delegate void HostAddressHandler (object o, string host, IPAddress address);
     

-    public class AddressResolver : IDisposable
+    public class AddressResolver : ResolverBase, IDisposable

     {
         private IntPtr handle;
         private Client client;
         private int iface;
         private Protocol proto;
         private IPAddress address;
     {
         private IntPtr handle;
         private Client client;
         private int iface;
         private Protocol proto;
         private IPAddress address;

+        private LookupFlags flags;
+        private AddressResolverCallback cb;

 
         private IPAddress currentAddress;
         private string currentHost;
 
         private IPAddress currentAddress;
         private string currentHost;


@@ -29,7 +52,8 @@ namespace Avahi
         
         [DllImport ("avahi-client")]
         private static extern IntPtr avahi_address_resolver_new (IntPtr client, int iface, Protocol proto,
         
         [DllImport ("avahi-client")]
         private static extern IntPtr avahi_address_resolver_new (IntPtr client, int iface, Protocol proto,

-                                                                 IntPtr address, AddressResolverCallback cb,
+                                                                 IntPtr address, LookupFlags flags,
+                                                                 AddressResolverCallback cb,

                                                                  IntPtr userdata);
 
         [DllImport ("avahi-client")]
                                                                  IntPtr userdata);
 
         [DllImport ("avahi-client")]


@@ -69,16 +93,19 @@ namespace Avahi
             get { return currentHost; }
         }
 
             get { return currentHost; }
         }
 

-        public AddressResolver (Client client, IPAddress address) : this (client, -1, Protocol.Unspecified, address)
+        public AddressResolver (Client client, IPAddress address) : this (client, -1, Protocol.Unspecified,
+                                                                          address, LookupFlags.None)

         {
         }
 
         {
         }
 

-        public AddressResolver (Client client, int iface, Protocol proto, IPAddress address)
+        public AddressResolver (Client client, int iface, Protocol proto, IPAddress address, LookupFlags flags)

         {
             this.client = client;
             this.iface = iface;
             this.proto = proto;
             this.address = address;
         {
             this.client = client;
             this.iface = iface;
             this.proto = proto;
             this.address = address;

+            this.flags = flags;
+            cb = OnAddressResolverCallback;

         }
 
         ~AddressResolver ()
         }
 
         ~AddressResolver ()


@@ -93,39 +120,54 @@ namespace Avahi
 
         private void Start ()
         {
 
         private void Start ()
         {

-            if (handle != IntPtr.Zero || (foundListeners.Count == 0 && timeoutListeners.Count == 0))
+            if (client.Handle == IntPtr.Zero || handle != IntPtr.Zero ||
+                (foundListeners.Count == 0 && timeoutListeners.Count == 0))

                 return;
 
             IntPtr addrPtr = Utility.StringToPtr (address.ToString ());
                 return;
 
             IntPtr addrPtr = Utility.StringToPtr (address.ToString ());

-            handle = avahi_address_resolver_new (client.Handle, iface, proto, addrPtr,
-                                                 OnAddressResolverCallback, IntPtr.Zero);
+
+            lock (client) {
+                handle = avahi_address_resolver_new (client.Handle, iface, proto, addrPtr, flags,
+                                                     cb, IntPtr.Zero);
+            }
+            

             Utility.Free (addrPtr);
         }
 
         private void Stop (bool force)
         {
             Utility.Free (addrPtr);
         }
 
         private void Stop (bool force)
         {

-            if (handle != IntPtr.Zero && (force || (foundListeners.Count == 0 && timeoutListeners.Count == 0))) {
-                avahi_address_resolver_free (handle);
-                handle = IntPtr.Zero;
+            if (client.Handle != IntPtr.Zero && handle != IntPtr.Zero &&
+                (force || (foundListeners.Count == 0 && timeoutListeners.Count == 0))) {
+
+                lock (client) {
+                    avahi_address_resolver_free (handle);
+                    handle = IntPtr.Zero;
+                }

             }
         }
 
         private void OnAddressResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                 ResolverEvent revent, Protocol aproto, IntPtr address,
             }
         }
 
         private void OnAddressResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                 ResolverEvent revent, Protocol aproto, IntPtr address,

-                                                IntPtr hostname, IntPtr userdata)
+                                                IntPtr hostname, LookupResultFlags flags, IntPtr userdata)

         {
         {

-            if (revent == ResolverEvent.Found) {
+            switch (revent) {
+            case ResolverEvent.Found:

                 currentAddress = Utility.PtrToAddress (address);
                 currentHost = Utility.PtrToString (hostname);
 
                 foreach (HostAddressHandler handler in foundListeners)
                     handler (this, currentHost, currentAddress);
                 currentAddress = Utility.PtrToAddress (address);
                 currentHost = Utility.PtrToString (hostname);
 
                 foreach (HostAddressHandler handler in foundListeners)
                     handler (this, currentHost, currentAddress);

-            } else {
+                break;
+            case ResolverEvent.Timeout:

                 currentAddress = null;
                 currentHost = null;
                 
                 foreach (EventHandler handler in timeoutListeners)
                     handler (this, new EventArgs ());
                 currentAddress = null;
                 currentHost = null;
                 
                 foreach (EventHandler handler in timeoutListeners)
                     handler (this, new EventArgs ());

+                break;
+            default:
+                EmitResolverEvent (revent);
+                break;

             }
         }
     }
             }
         }
     }