Branching for wide-area publishing work

  


git-svn-id: file:///home/lennart/svn/public/avahi/branches/federico@1344 941a03a8-eaeb-0310-b9a0-b1bbd8fe43fe

1 files changed, 378 insertions, 0 deletions

diff --git a/trunk/avahi-sharp/EntryGroup.cs b/trunk/avahi-sharp/EntryGroup.cs
new file mode 100644
index 0000000..02be643
--- /dev/null
+++ b/trunk/avahi-sharp/EntryGroup.cs
@@ -0,0 +1,378 @@
+/* $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.Net;
+using System.Runtime.InteropServices;
+using System.Text;
+using Mono.Unix;
+
+namespace Avahi
+{
+
+    [Flags]
+    public enum PublishFlags {
+        None = 0,
+        Unique = 1,
+        NoProbe = 2,
+        NoAnnounce = 4,
+        AllowMultiple = 8,
+        NoReverse = 16,
+        NoCookie = 32,
+        Update = 64,
+        UseWideArea = 128,
+        UseMulticast = 256
+    }
+    
+    public enum EntryGroupState {
+        Uncommited,
+        Registering,
+        Established,
+        Collision,
+        Failure
+    }
+
+    public class EntryGroupStateArgs : EventArgs
+    {
+        private EntryGroupState state;
+
+        public EntryGroupState State
+        {
+            get { return state; }
+        }
+        
+        public EntryGroupStateArgs (EntryGroupState state)
+        {
+            this.state = state;
+        }
+    }
+
+    internal delegate void EntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata);
+    public delegate void EntryGroupStateHandler (object o, EntryGroupStateArgs args);
+    
+    public class EntryGroup : IDisposable
+    {
+        private Client client;
+        private IntPtr handle;
+        private EntryGroupCallback cb;
+        
+        [DllImport ("avahi-client")]
+        private static extern IntPtr avahi_entry_group_new (IntPtr client, EntryGroupCallback cb, IntPtr userdata);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_commit (IntPtr group);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_reset (IntPtr group);
+
+        [DllImport ("avahi-client")]
+        private static extern EntryGroupState avahi_entry_group_get_state (IntPtr group);
+
+        [DllImport ("avahi-client")]
+        private static extern bool avahi_entry_group_is_empty (IntPtr group);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_add_service_strlst (IntPtr group, int iface, Protocol proto,
+                                                                        PublishFlags flags, byte[] name, byte[] type,
+                                                                        byte[] domain, byte[] host, UInt16 port,
+                                                                        IntPtr strlst);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_update_service_strlst (IntPtr group, int iface, Protocol proto,
+                                                                           PublishFlags flags, byte[] name,
+                                                                           byte[] type, byte[] domain, IntPtr strlst);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_add_service_subtype (IntPtr group, int iface, Protocol proto,
+                                                                         PublishFlags flags, byte[] name, byte[] type,
+                                                                         byte[] domain, byte[] subtype);
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_add_address (IntPtr group, int iface, Protocol proto,
+                                                                 PublishFlags flags, byte[] name, IntPtr address);
+
+
+        [DllImport ("avahi-client")]
+        private static extern int avahi_entry_group_add_record (IntPtr group, int iface, Protocol proto,
+                                                                PublishFlags flags, byte[] name, RecordClass clazz,
+                                                                RecordType type, uint ttl, byte[] rdata, int size);
+        
+        [DllImport ("avahi-client")]
+        private static extern void avahi_entry_group_free (IntPtr group);
+
+        [DllImport ("avahi-common")]
+        private static extern IntPtr avahi_string_list_new (IntPtr txt);
+
+        [DllImport ("avahi-common")]
+        private static extern IntPtr avahi_string_list_add (IntPtr list, byte[] txt);
+
+        [DllImport ("avahi-common")]
+        private static extern void avahi_string_list_free (IntPtr list);
+
+        [DllImport ("avahi-common")]
+        private static extern IntPtr avahi_alternative_service_name (byte[] name);
+
+        public event EntryGroupStateHandler StateChanged;
+        
+        public EntryGroupState State
+        {
+            get {
+                lock (client) {
+                    return avahi_entry_group_get_state (handle);
+                }
+            }
+        }
+
+        public bool IsEmpty
+        {
+            get {
+                lock (client) {
+                    return avahi_entry_group_is_empty (handle);
+                }
+            }
+        }
+        
+        public EntryGroup (Client client)
+        {
+            this.client = client;
+            cb = OnEntryGroupCallback;
+
+            lock (client) {
+                handle = avahi_entry_group_new (client.Handle, cb, IntPtr.Zero);
+                if (handle == IntPtr.Zero)
+                    client.ThrowError ();
+            }
+        }
+
+        ~EntryGroup ()
+        {
+            Dispose ();
+        }
+
+        public void Dispose ()
+        {
+            if (client.Handle != IntPtr.Zero && handle != IntPtr.Zero) {
+                lock (client) {
+                    avahi_entry_group_free (handle);
+                    handle = IntPtr.Zero;
+                }
+            }
+        }
+
+        public void Commit ()
+        {
+            lock (client) {
+                if (avahi_entry_group_commit (handle) < 0)
+                    client.ThrowError ();
+            }
+        }
+
+        public void Reset ()
+        {
+            lock (client) {
+                if (avahi_entry_group_reset (handle) < 0)
+                    client.ThrowError ();
+            }
+        }
+
+        public void AddService (string name, string type, string domain,
+                                UInt16 port, params string[] txt)
+        {
+            AddService (PublishFlags.None, name, type, domain, port, txt);
+        }
+
+        public void AddService (PublishFlags flags, string name, string type, string domain,
+                                UInt16 port, params string[] txt)
+        {
+            AddService (-1, Protocol.Unspecified, flags, name, type, domain, null, port, txt);
+        }
+
+        public void AddService (int iface, Protocol proto, PublishFlags flags, string name, string type, string domain,
+                                string host, UInt16 port, params string[] txt)
+        {
+            IntPtr list = avahi_string_list_new (IntPtr.Zero);
+
+            if (txt != null) {
+                foreach (string item in txt) {
+                    list = avahi_string_list_add (list, Utility.StringToBytes (item));
+                }
+            }
+
+            AddService (iface, proto, flags, name, type, domain, host, port, list);
+        }
+
+        public void AddService (int iface, Protocol proto, PublishFlags flags, string name, string type, string domain,
+                                string host, UInt16 port, params byte[][] txt)
+        {
+            IntPtr list = avahi_string_list_new (IntPtr.Zero);
+
+            if (txt != null) {
+                foreach (byte[] item in txt) {
+                    list = avahi_string_list_add (list, item);
+                }
+            }
+
+            AddService (iface, proto, flags, name, type, domain, host, port, list);
+        }
+
+        private void AddService (int iface, Protocol proto, PublishFlags flags, string name, string type,
+                                 string domain, string host, UInt16 port, IntPtr list)
+        {
+            int ret;
+
+            lock (client) {
+                ret = avahi_entry_group_add_service_strlst (handle, iface, proto, flags,
+                                                            Utility.StringToBytes (name),
+                                                            Utility.StringToBytes (type),
+                                                            Utility.StringToBytes (domain),
+                                                            Utility.StringToBytes (host), port, list);
+            }
+            
+            avahi_string_list_free (list);
+            
+            if (ret < 0) {
+                client.ThrowError ();
+            }
+        }
+
+        public void UpdateService (string name, string type, string domain, params string[] txt)
+        {
+            UpdateService (-1, Protocol.Unspecified, PublishFlags.None, name, type, domain, txt);
+        }
+
+        public void UpdateService (int iface, Protocol proto, PublishFlags flags, string name, string type,
+                                   string domain, params string[] txt)
+        {
+            IntPtr list = avahi_string_list_new (IntPtr.Zero);
+
+            if (txt != null) {
+                foreach (string item in txt) {
+                    list = avahi_string_list_add (list, Utility.StringToBytes (item));
+                }
+            }
+
+            UpdateService (iface, proto, flags, name, type, domain, list);
+        }
+
+        public void UpdateService (int iface, Protocol proto, PublishFlags flags, string name, string type,
+                                   string domain, params byte[][] txt)
+        {
+            IntPtr list = avahi_string_list_new (IntPtr.Zero);
+
+            if (txt != null) {
+                foreach (byte[] item in txt) {
+                    list = avahi_string_list_add (list, item);
+                }
+            }
+
+            UpdateService (iface, proto, flags, name, type, domain, list);
+        }
+        
+        private void UpdateService (int iface, Protocol proto, PublishFlags flags, string name, string type,
+                                    string domain, IntPtr list)
+        {
+            lock (client) {
+                int ret = avahi_entry_group_update_service_strlst (handle, iface, proto, flags,
+                                                                   Utility.StringToBytes (name),
+                                                                   Utility.StringToBytes (type),
+                                                                   Utility.StringToBytes (domain),
+                                                                   list);
+
+                avahi_string_list_free (list);
+
+                if (ret < 0) {
+                    client.ThrowError ();
+                }
+            }
+        }
+
+        public void AddServiceSubtype (string name, string type, string domain, string subtype)
+        {
+            AddServiceSubtype (-1, Protocol.Unspecified, PublishFlags.None, name, type, domain, subtype);
+        }
+
+        public void AddServiceSubtype (int iface, Protocol proto, PublishFlags flags, string name,
+                                       string type, string domain, string subtype)
+        {
+            lock (client) {
+                int ret = avahi_entry_group_add_service_subtype (handle, iface, proto, flags,
+                                                                 Utility.StringToBytes (name),
+                                                                 Utility.StringToBytes (type),
+                                                                 Utility.StringToBytes (domain),
+                                                                 Utility.StringToBytes (subtype));
+
+                if (ret < 0) {
+                    client.ThrowError ();
+                }
+            }
+        }
+
+        public void AddAddress (string name, IPAddress address)
+        {
+            AddAddress (-1, Protocol.Unspecified, PublishFlags.None, name, address);
+        }
+
+        public void AddAddress (int iface, Protocol proto, PublishFlags flags, string name, IPAddress address)
+        {
+            IntPtr addressPtr = Utility.AddressToPtr (address);
+
+            lock (client) {
+                int ret = avahi_entry_group_add_address (handle, iface, proto, flags,
+                                                         Utility.StringToBytes (name), addressPtr);
+
+                Utility.Free (addressPtr);
+
+                if (ret < 0) {
+                    client.ThrowError ();
+                }
+            }
+        }
+
+        public void AddRecord (string name, RecordClass clazz, RecordType type, uint ttl, byte[] rdata, int length)
+        {
+            AddRecord (-1, Protocol.Unspecified, PublishFlags.None, name, clazz, type, ttl, rdata, length);
+        }
+
+        public void AddRecord (int iface, Protocol proto, PublishFlags flags, string name,
+                               RecordClass clazz, RecordType type, uint ttl, byte[] rdata, int length)
+        {
+            lock (client) {
+                int ret = avahi_entry_group_add_record (handle, iface, proto, flags,
+                                                        Utility.StringToBytes (name),
+                                                        clazz, type, ttl, rdata, length);
+
+                if (ret < 0) {
+                    client.ThrowError ();
+                }
+            }
+        }
+
+        public static string GetAlternativeServiceName (string name) {
+            return Utility.PtrToStringFree (avahi_alternative_service_name (Utility.StringToBytes (name)));
+        }
+
+        private void OnEntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata)
+        {
+            if (StateChanged != null)
+                StateChanged (this, new EntryGroupStateArgs (state));
+        }
+    }
+}