* 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 6b0d0309f0a7c1ac92780d293521577589d3f7c0..01211aecd9cb6e20676c5efe260decfcda3369a9 100644 (file)
--- a/avahi-sharp/AddressResolver.cs
+++ b/avahi-sharp/AddressResolver.cs
@@ -30,17 +30,18 @@ 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 AddressResolverCallback cb;
 
         private IPAddress currentAddress;


@@ -51,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")]


@@ -91,16 +93,18 @@ 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;
         }
 
             cb = OnAddressResolverCallback;
         }
 


@@ -116,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,
-                                                 cb, 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;

             }
         }
     }
             }
         }
     }