fix avahi_netlink_new to allow multiple netlinks per process

[catta] / avahi-sharp / ServiceResolver.cs

diff --git a/avahi-sharp/ServiceResolver.cs b/avahi-sharp/ServiceResolver.cs
index 50142975fa39a236ee8b6381b2c33d3510a87c43..7f8901a177a6beefe0ae7ac5a672bf29c0c421cc 100644 (file)
--- a/avahi-sharp/ServiceResolver.cs
+++ b/avahi-sharp/ServiceResolver.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


@@ -29,9 +30,10 @@ namespace Avahi
     internal delegate void ServiceResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                     ResolverEvent revent, IntPtr name, IntPtr type,
                                                     IntPtr domain, IntPtr host, IntPtr address,
     internal delegate void ServiceResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                     ResolverEvent revent, IntPtr name, IntPtr type,
                                                     IntPtr domain, IntPtr host, IntPtr address,

-                                                    UInt16 port, IntPtr txt, IntPtr userdata);
+                                                    UInt16 port, IntPtr txt, LookupResultFlags flags,
+                                                    IntPtr userdata);

 
 

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

     {
         private IntPtr handle;
         private ServiceInfo currentInfo;
     {
         private IntPtr handle;
         private ServiceInfo currentInfo;


@@ -42,16 +44,28 @@ namespace Avahi
         private string type;
         private string domain;
         private Protocol aproto;
         private string type;
         private string domain;
         private Protocol aproto;

+        private LookupFlags flags;
+        private ServiceResolverCallback cb;

 
         private ArrayList foundListeners = new ArrayList ();
         private ArrayList timeoutListeners = new ArrayList ();
 
         private ArrayList foundListeners = new ArrayList ();
         private ArrayList timeoutListeners = new ArrayList ();

-        
+

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

-                                                                 IntPtr name, IntPtr type, IntPtr domain,
-                                                                 Protocol aproto, ServiceResolverCallback cb,
+                                                                 byte[] name, byte[] type, byte[] domain,
+                                                                 Protocol aproto, LookupFlags flags,
+                                                                 ServiceResolverCallback cb,

                                                                  IntPtr userdata);
 
                                                                  IntPtr userdata);
 

+        [DllImport ("avahi-common")]
+        private static extern IntPtr avahi_string_list_get_next (IntPtr list);
+
+        [DllImport ("avahi-common")]
+        private static extern IntPtr avahi_string_list_get_text (IntPtr list);
+
+        [DllImport ("avahi-common")]
+        private static extern int avahi_string_list_get_size (IntPtr list);
+

         [DllImport ("avahi-client")]
         private static extern void avahi_service_resolver_free (IntPtr handle);
 
         [DllImport ("avahi-client")]
         private static extern void avahi_service_resolver_free (IntPtr handle);
 


@@ -66,7 +80,7 @@ namespace Avahi
                 Stop (false);
             }
         }
                 Stop (false);
             }
         }

-        
+

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


@@ -87,19 +101,21 @@ namespace Avahi
         public ServiceResolver (Client client, string name, string type, string domain) : this (client, -1,
                                                                                                 Protocol.Unspecified,
                                                                                                 name, type, domain,
         public ServiceResolver (Client client, string name, string type, string domain) : this (client, -1,
                                                                                                 Protocol.Unspecified,
                                                                                                 name, type, domain,

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

         {
         }
 
         public ServiceResolver (Client client, ServiceInfo service) : this (client, service.NetworkInterface,
                                                                             service.Protocol, service.Name,
                                                                             service.ServiceType, service.Domain,
         {
         }
 
         public ServiceResolver (Client client, ServiceInfo service) : this (client, service.NetworkInterface,
                                                                             service.Protocol, service.Name,
                                                                             service.ServiceType, service.Domain,

-                                                                            Protocol.Unspecified)
+                                                                            Protocol.Unspecified,
+                                                                            GetLookupFlags (service.Flags))

         {
         }
         {
         }

-        
+

         public ServiceResolver (Client client, int iface, Protocol proto, string name,
         public ServiceResolver (Client client, int iface, Protocol proto, string name,

-                                string type, string domain, Protocol aproto)
+                                string type, string domain, Protocol aproto, LookupFlags flags)

         {
             this.client = client;
             this.iface = iface;
         {
             this.client = client;
             this.iface = iface;


@@ -108,8 +124,8 @@ namespace Avahi
             this.type = type;
             this.domain = domain;
             this.aproto = aproto;
             this.type = type;
             this.domain = domain;
             this.aproto = aproto;

-            
-            
+            this.flags = flags;
+            cb = OnServiceResolverCallback;

         }
 
         ~ServiceResolver ()
         }
 
         ~ServiceResolver ()


@@ -124,31 +140,37 @@ 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 namePtr = Utility.StringToPtr (name);
-            IntPtr typePtr = Utility.StringToPtr (type);
-            IntPtr domainPtr = Utility.StringToPtr (domain);
-            handle = avahi_service_resolver_new (client.Handle, iface, proto, namePtr, typePtr, domainPtr,
-                                                 aproto, OnServiceResolverCallback, IntPtr.Zero);
-            Utility.Free (namePtr);
-            Utility.Free (typePtr);
-            Utility.Free (domainPtr);
+            lock (client) {
+                handle = avahi_service_resolver_new (client.Handle, iface, proto,
+                                                     Utility.StringToBytes (name), Utility.StringToBytes (type),
+                                                     Utility.StringToBytes (domain), 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_service_resolver_free (handle);
-                handle = IntPtr.Zero;
+            if (client.Handle != IntPtr.Zero && handle != IntPtr.Zero &&
+                (force || (foundListeners.Count == 0 && timeoutListeners.Count == 0))) {
+
+                lock (client) {
+                    avahi_service_resolver_free (handle);
+                    handle = IntPtr.Zero;
+                }

             }
         }
 
         private void OnServiceResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                 ResolverEvent revent, IntPtr name, IntPtr type,
                                                 IntPtr domain, IntPtr host, IntPtr address,
             }
         }
 
         private void OnServiceResolverCallback (IntPtr resolver, int iface, Protocol proto,
                                                 ResolverEvent revent, IntPtr name, IntPtr type,
                                                 IntPtr domain, IntPtr host, IntPtr address,

-                                                UInt16 port, IntPtr txt, IntPtr userdata)
+                                                UInt16 port, IntPtr txt, LookupResultFlags flags,
+                                                IntPtr userdata)

         {
             ServiceInfo info;
             info.NetworkInterface = iface;
         {
             ServiceInfo info;
             info.NetworkInterface = iface;


@@ -156,22 +178,48 @@ namespace Avahi
             info.Domain = Utility.PtrToString (domain);
             info.ServiceType = Utility.PtrToString (type);
             info.Name = Utility.PtrToString (name);
             info.Domain = Utility.PtrToString (domain);
             info.ServiceType = Utility.PtrToString (type);
             info.Name = Utility.PtrToString (name);

-            info.Host = Utility.PtrToString (host);
+            info.HostName = Utility.PtrToString (host);

             info.Address = Utility.PtrToAddress (address);
             info.Port = port;
             info.Address = Utility.PtrToAddress (address);
             info.Port = port;

-            info.Text = null;

 
 

-            if (revent == ResolverEvent.Found) {
+            if (proto == Protocol.IPv6)
+              info.Address.ScopeId = iface;
+
+            ArrayList txtlist = new ArrayList ();
+            for (IntPtr l = txt; l != IntPtr.Zero; l = avahi_string_list_get_next (l)) {
+                IntPtr buf = avahi_string_list_get_text (l);
+                int len = avahi_string_list_get_size (l);
+
+                byte[] txtbuf = new byte[len];
+                Marshal.Copy (buf, txtbuf, 0, len);
+                txtlist.Add (txtbuf);
+            }
+
+            info.Text = (byte[][]) txtlist.ToArray (typeof (byte[]));
+            info.Flags = flags;
+
+            switch (revent) {
+            case ResolverEvent.Found:

                 currentInfo = info;
 
                 foreach (ServiceInfoHandler handler in foundListeners)
                 currentInfo = info;
 
                 foreach (ServiceInfoHandler handler in foundListeners)

-                    handler (this, info);
-            } else {
-                currentInfo = ServiceInfo.Zero;
-                
-                foreach (EventHandler handler in timeoutListeners)
-                    handler (this, new EventArgs ());
+                    handler (this, new ServiceInfoArgs (info));
+                break;
+            case ResolverEvent.Failure:
+                EmitFailure (client.LastError);
+                break;

             }
         }
             }
         }

+
+        private static LookupFlags GetLookupFlags (LookupResultFlags rflags) {
+            LookupFlags ret = LookupFlags.None;
+
+            if ((rflags & LookupResultFlags.Multicast) > 0)
+                ret |= LookupFlags.UseMulticast;
+            if ((rflags & LookupResultFlags.WideArea) > 0)
+                ret |= LookupFlags.UseWideArea;
+
+            return ret;
+        }

     }
 }
     }
 }