### BACKPORT ###

[catta] / avahi-sharp / AddressResolver.cs

diff --git a/avahi-sharp/AddressResolver.cs b/avahi-sharp/AddressResolver.cs
index 8a0b66ba6e3d63ce2f6b280af0b40e423f53394a..01211aecd9cb6e20676c5efe260decfcda3369a9 100644 (file)
--- a/avahi-sharp/AddressResolver.cs
+++ b/avahi-sharp/AddressResolver.cs
@@ -30,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;


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


@@ -90,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 ()


@@ -114,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;

             }
         }
     }
             }
         }
     }