]> git.meshlink.io Git - catta/blob - avahi-sharp/EntryGroup.cs
Complete AVAHI_LOOKUP_NO_ADDRESS fix
[catta] / 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     public enum EntryGroupState {
30         Uncommited,
31         Registering,
32         Established,
33         Collision
34     }
35
36     internal delegate void EntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata);
37     public delegate void EntryGroupStateHandler (object o, EntryGroupState state);
38     
39     public class EntryGroup : IDisposable
40     {
41         private Client client;
42         private IntPtr handle;
43         private EntryGroupCallback cb;
44         
45         [DllImport ("avahi-client")]
46         private static extern IntPtr avahi_entry_group_new (IntPtr client, EntryGroupCallback cb, IntPtr userdata);
47
48         [DllImport ("avahi-client")]
49         private static extern void avahi_entry_group_commit (IntPtr group);
50
51         [DllImport ("avahi-client")]
52         private static extern void avahi_entry_group_reset (IntPtr group);
53
54         [DllImport ("avahi-client")]
55         private static extern EntryGroupState avahi_entry_group_get_state (IntPtr group);
56
57         [DllImport ("avahi-client")]
58         private static extern bool avahi_entry_group_is_empty (IntPtr group);
59
60         [DllImport ("avahi-client")]
61         private static extern void avahi_entry_group_add_service_strlst (IntPtr group, int iface, Protocol proto,
62                                                                          IntPtr name, IntPtr type, IntPtr domain,
63                                                                          IntPtr host, UInt16 port, IntPtr strlst);
64         
65         [DllImport ("avahi-client")]
66         private static extern void avahi_entry_group_free (IntPtr group);
67
68         [DllImport ("avahi-common")]
69         private static extern IntPtr avahi_string_list_new (IntPtr txt);
70
71         [DllImport ("avahi-common")]
72         private static extern IntPtr avahi_string_list_add (IntPtr list, IntPtr txt);
73
74         [DllImport ("avahi-common")]
75         private static extern void avahi_string_list_free (IntPtr list);
76
77         [DllImport ("avahi-common")]
78         private static extern IntPtr avahi_alternative_service_name (IntPtr name);
79
80         public event EntryGroupStateHandler StateChanged;
81         
82         public EntryGroupState State
83         {
84             get {
85                 lock (client) {
86                     return avahi_entry_group_get_state (handle);
87                 }
88             }
89         }
90
91         public bool IsEmpty
92         {
93             get {
94                 lock (client) {
95                     return avahi_entry_group_is_empty (handle);
96                 }
97             }
98         }
99         
100         public EntryGroup (Client client)
101         {
102             this.client = client;
103             cb = OnEntryGroupCallback;
104
105             lock (client) {
106                 handle = avahi_entry_group_new (client.Handle, cb, IntPtr.Zero);
107                 client.CheckError ();
108             }
109         }
110
111         ~EntryGroup ()
112         {
113             Dispose ();
114         }
115
116         public void Dispose ()
117         {
118             if (client.Handle != IntPtr.Zero && handle != IntPtr.Zero) {
119                 lock (client) {
120                     avahi_entry_group_free (handle);
121                     handle = IntPtr.Zero;
122                 }
123             }
124         }
125
126         public void Commit ()
127         {
128             lock (client) {
129                 avahi_entry_group_commit (handle);
130                 client.CheckError ();
131             }
132         }
133
134         public void Reset ()
135         {
136             lock (client) {
137                 avahi_entry_group_reset (handle);
138                 client.CheckError ();
139             }
140         }
141
142         public void AddService (string name, string type, string domain,
143                                 UInt16 port, params string[] txt)
144         {
145             AddService (-1, Protocol.Unspecified, name, type, domain, null, port, txt);
146         }
147
148         public void AddService (int iface, Protocol proto, string name, string type, string domain,
149                                 string host, UInt16 port, params string[] txt)
150         {
151             IntPtr list = avahi_string_list_new (IntPtr.Zero);
152
153             if (txt != null) {
154                 foreach (string item in txt) {
155                     IntPtr itemPtr = Utility.StringToPtr (item);
156                     list = avahi_string_list_add (list, itemPtr);
157                     Utility.Free (itemPtr);
158                 }
159             }
160
161             IntPtr namePtr = Utility.StringToPtr (name);
162             IntPtr typePtr = Utility.StringToPtr (type);
163             IntPtr domainPtr = Utility.StringToPtr (domain);
164             IntPtr hostPtr = Utility.StringToPtr (host);
165
166             lock (client) {
167                 avahi_entry_group_add_service_strlst (handle, iface, proto, namePtr, typePtr, domainPtr,
168                                                       hostPtr, port, list);
169             }
170             
171             avahi_string_list_free (list);
172
173             client.CheckError ();
174         }
175
176         public static string GetAlternativeServiceName (string name) {
177             IntPtr namePtr = Utility.StringToPtr (name);
178             IntPtr result = avahi_alternative_service_name (namePtr);
179             Utility.Free (namePtr);
180
181             return Utility.PtrToStringFree (result);
182         }
183
184         private void OnEntryGroupCallback (IntPtr group, EntryGroupState state, IntPtr userdata)
185         {
186             if (StateChanged != null)
187                 StateChanged (this, state);
188         }
189     }
190 }