fix avahi_netlink_new to allow multiple netlinks per process

[catta] / avahi-sharp / HostNameResolver.cs

diff --git a/avahi-sharp/HostNameResolver.cs b/avahi-sharp/HostNameResolver.cs
index de2ff51b38cd2a23a58c44b5a1d0cc2a34932191..b9fe7f4348e8da6aac2e363efd0d70ecf36cbab6 100644 (file)
--- a/avahi-sharp/HostNameResolver.cs
+++ b/avahi-sharp/HostNameResolver.cs
@@ -21,6 +21,7 @@ using System;
 using System.Collections;
 using System.Net;
 using System.Runtime.InteropServices;
 using System.Collections;
 using System.Net;
 using System.Runtime.InteropServices;

+using System.Text;

 using Mono.Unix;
 
 namespace Avahi
 using Mono.Unix;
 
 namespace Avahi


@@ -28,9 +29,9 @@ namespace Avahi
 
     internal delegate void HostNameResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                      ResolverEvent revent, IntPtr hostname, IntPtr address,
 
     internal delegate void HostNameResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                      ResolverEvent revent, IntPtr hostname, IntPtr address,

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

 
 

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

     {
         private IntPtr handle;
         private Client client;
     {
         private IntPtr handle;
         private Client client;


@@ -38,16 +39,18 @@ namespace Avahi
         private Protocol proto;
         private string hostname;
         private Protocol aproto;
         private Protocol proto;
         private string hostname;
         private Protocol aproto;

+        private LookupFlags flags;
+        private HostNameResolverCallback cb;

 
         private IPAddress currentAddress;
         private string currentHost;
 
         private ArrayList foundListeners = new ArrayList ();
         private ArrayList timeoutListeners = new ArrayList ();
 
         private IPAddress currentAddress;
         private string currentHost;
 
         private ArrayList foundListeners = new ArrayList ();
         private ArrayList timeoutListeners = new ArrayList ();

-        
+

         [DllImport ("avahi-client")]
         private static extern IntPtr avahi_host_name_resolver_new (IntPtr client, int iface, Protocol proto,
         [DllImport ("avahi-client")]
         private static extern IntPtr avahi_host_name_resolver_new (IntPtr client, int iface, Protocol proto,

-                                                                   IntPtr hostname, Protocol aproto,
+                                                                   byte[] hostname, Protocol aproto, LookupFlags flags,

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


@@ -64,7 +67,7 @@ namespace Avahi
                 Stop (false);
             }
         }
                 Stop (false);
             }
         }

-        
+

         public event EventHandler Timeout
         {
             add {
         public event EventHandler Timeout
         {
             add {


@@ -88,18 +91,21 @@ namespace Avahi
         }
 
         public HostNameResolver (Client client, string hostname) : this (client, -1, Protocol.Unspecified,
         }
 
         public HostNameResolver (Client client, string hostname) : this (client, -1, Protocol.Unspecified,

-                                                                         hostname, Protocol.Unspecified)
+                                                                         hostname, Protocol.Unspecified,
+                                                                         LookupFlags.None)

         {
         }
 
         public HostNameResolver (Client client, int iface, Protocol proto, string hostname,
         {
         }
 
         public HostNameResolver (Client client, int iface, Protocol proto, string hostname,

-                                 Protocol aproto)
+                                 Protocol aproto, LookupFlags flags)

         {
             this.client = client;
             this.iface = iface;
             this.proto = proto;
             this.hostname = hostname;
             this.aproto = aproto;
         {
             this.client = client;
             this.iface = iface;
             this.proto = proto;
             this.hostname = hostname;
             this.aproto = aproto;

+            this.flags = flags;
+            cb = OnHostNameResolverCallback;

         }
 
         ~HostNameResolver ()
         }
 
         ~HostNameResolver ()


@@ -114,39 +120,47 @@ 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;
 
                 return;
 

-            IntPtr hostPtr = Utility.StringToPtr (hostname);
-            handle = avahi_host_name_resolver_new (client.Handle, iface, proto, hostPtr, aproto,
-                                                   OnHostNameResolverCallback, IntPtr.Zero);
-            Utility.Free (hostPtr);
+            lock (client) {
+                handle = avahi_host_name_resolver_new (client.Handle, iface, proto,
+                                                       Utility.StringToBytes (hostname), aproto, flags,
+                                                       cb, IntPtr.Zero);
+
+                if (handle == IntPtr.Zero)
+                    client.ThrowError ();
+            }

         }
 
         private void Stop (bool force)
         {
         }
 
         private void Stop (bool force)
         {

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

             }
         }
 
         private void OnHostNameResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                  ResolverEvent revent, IntPtr hostname, IntPtr address,
             }
         }
 
         private void OnHostNameResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                  ResolverEvent revent, IntPtr hostname, IntPtr address,

-                                                 IntPtr userdata)
+                                                 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)
                 currentAddress = Utility.PtrToAddress (address);
                 currentHost = Utility.PtrToString (hostname);
 
                 foreach (HostAddressHandler handler in foundListeners)

-                    handler (this, currentHost, currentAddress);
-            } else {
-                currentAddress = null;
-                currentHost = null;
-                
-                foreach (EventHandler handler in timeoutListeners)
-                    handler (this, new EventArgs ());
+                    handler (this, new HostAddressArgs (currentHost, currentAddress));
+                break;
+            case ResolverEvent.Failure:
+                EmitFailure (client.LastError);
+                break;

             }
         }
     }
             }
         }
     }