git.meshlink.io Git - catta/blob - avahi-sharp/EntryGroup.cs

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 using System;
  23 using System.Runtime.InteropServices;
  24
  25
  26 namespace Avahi
  27 {
  28
  29     [Flags]
  30     public enum PublishFlags {
  31         None = 0,
  32         Unique = 1,
  33         NoProbe = 2,
  34         NoAnnounce = 4,
  35         AllowMultiple = 8,
  36         NoReverse = 16,
  37         NoCookie = 32,
  38         Update = 64
  39     }
  40
  41     public enum EntryGroupState {
  42         Uncommited,
  43         Registering,
  44         Established,
  45         Collision,
  46         Failure
  47     }
  48
  49     internal delegate void EntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata);
  50     public delegate void EntryGroupStateHandler (object o, EntryGroupState state);
  51
  52     public class EntryGroup : IDisposable
  53     {
  54         private Client client;
  55         private IntPtr handle;
  56         private EntryGroupCallback cb;
  57
  58         [DllImport ("avahi-client")]
  59         private static extern IntPtr avahi_entry_group_new (IntPtr client, EntryGroupCallback cb, IntPtr userdata);
  60
  61         [DllImport ("avahi-client")]
  62         private static extern int avahi_entry_group_commit (IntPtr group);
  63
  64         [DllImport ("avahi-client")]
  65         private static extern int avahi_entry_group_reset (IntPtr group);
  66
  67         [DllImport ("avahi-client")]
  68         private static extern EntryGroupState avahi_entry_group_get_state (IntPtr group);
  69
  70         [DllImport ("avahi-client")]
  71         private static extern bool avahi_entry_group_is_empty (IntPtr group);
  72
  73         [DllImport ("avahi-client")]
  74         private static extern int avahi_entry_group_add_service_strlst (IntPtr group, int iface, Protocol proto,
  75                                                                         PublishFlags flags, IntPtr name, IntPtr type,
  76                                                                         IntPtr domain, IntPtr host, UInt16 port,
  77                                                                         IntPtr strlst);
  78
  79         [DllImport ("avahi-client")]
  80         private static extern void avahi_entry_group_free (IntPtr group);
  81
  82         [DllImport ("avahi-common")]
  83         private static extern IntPtr avahi_string_list_new (IntPtr txt);
  84
  85         [DllImport ("avahi-common")]
  86         private static extern IntPtr avahi_string_list_add (IntPtr list, IntPtr txt);
  87
  88         [DllImport ("avahi-common")]
  89         private static extern void avahi_string_list_free (IntPtr list);
  90
  91         [DllImport ("avahi-common")]
  92         private static extern IntPtr avahi_alternative_service_name (IntPtr name);
  93
  94         public event EntryGroupStateHandler StateChanged;
  95
  96         public EntryGroupState State
  97         {
  98             get {
  99                 lock (client) {
 100                     return avahi_entry_group_get_state (handle);
 101                 }
 102             }
 103         }
 104
 105         public bool IsEmpty
 106         {
 107             get {
 108                 lock (client) {
 109                     return avahi_entry_group_is_empty (handle);
 110                 }
 111             }
 112         }
 113
 114         public EntryGroup (Client client)
 115         {
 116             this.client = client;
 117             cb = OnEntryGroupCallback;
 118
 119             lock (client) {
 120                 handle = avahi_entry_group_new (client.Handle, cb, IntPtr.Zero);
 121                 if (handle == IntPtr.Zero)
 122                     client.ThrowError ();
 123             }
 124         }
 125
 126         ~EntryGroup ()
 127         {
 128             Dispose ();
 129         }
 130
 131         public void Dispose ()
 132         {
 133             if (client.Handle != IntPtr.Zero && handle != IntPtr.Zero) {
 134                 lock (client) {
 135                     avahi_entry_group_free (handle);
 136                     handle = IntPtr.Zero;
 137                 }
 138             }
 139         }
 140
 141         public void Commit ()
 142         {
 143             lock (client) {
 144                 if (avahi_entry_group_commit (handle) < 0)
 145                     client.ThrowError ();
 146             }
 147         }
 148
 149         public void Reset ()
 150         {
 151             lock (client) {
 152                 if (avahi_entry_group_reset (handle) < 0)
 153                     client.ThrowError ();
 154             }
 155         }
 156
 157         public void AddService (string name, string type, string domain,
 158                                 UInt16 port, params string[] txt)
 159         {
 160             AddService (PublishFlags.None, name, type, domain, port, txt);
 161         }
 162
 163         public void AddService (PublishFlags flags, string name, string type, string domain,
 164                                 UInt16 port, params string[] txt)
 165         {
 166             AddService (-1, Protocol.Unspecified, flags, name, type, domain, null, port, txt);
 167         }
 168
 169         public void AddService (int iface, Protocol proto, PublishFlags flags, string name, string type, string domain,
 170                                 string host, UInt16 port, params string[] txt)
 171         {
 172             IntPtr list = avahi_string_list_new (IntPtr.Zero);
 173
 174             if (txt != null) {
 175                 foreach (string item in txt) {
 176                     IntPtr itemPtr = Utility.StringToPtr (item);
 177                     list = avahi_string_list_add (list, itemPtr);
 178                     Utility.Free (itemPtr);
 179                 }
 180             }
 181
 182             IntPtr namePtr = Utility.StringToPtr (name);
 183             IntPtr typePtr = Utility.StringToPtr (type);
 184             IntPtr domainPtr = Utility.StringToPtr (domain);
 185             IntPtr hostPtr = Utility.StringToPtr (host);
 186
 187             lock (client) {
 188                 int ret = avahi_entry_group_add_service_strlst (handle, iface, proto, flags, namePtr, typePtr, domainPtr,
 189                                                                 hostPtr, port, list);
 190                 if (ret < 0) {
 191                     client.ThrowError ();
 192                 }
 193             }
 194
 195             avahi_string_list_free (list);
 196         }
 197
 198         public static string GetAlternativeServiceName (string name) {
 199             IntPtr namePtr = Utility.StringToPtr (name);
 200             IntPtr result = avahi_alternative_service_name (namePtr);
 201             Utility.Free (namePtr);
 202
 203             return Utility.PtrToStringFree (result);
 204         }
 205
 206         private void OnEntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata)
 207         {
 208             if (StateChanged != null)
 209                 StateChanged (this, state);
 210         }
 211     }
 212 }