]> git.meshlink.io Git - catta/blob - avahi-compat-howl/include/discovery/discovery.h
add updated specs to svn
[catta] / avahi-compat-howl / include / discovery / discovery.h
1 #ifndef _discovery_discovery_h
2 #define _discovery_discovery_h
3
4 /*
5  * Copyright 2003, 2004 Porchdog Software. All rights reserved.
6  *
7  *      Redistribution and use in source and binary forms, with or without modification,
8  *      are permitted provided that the following conditions are met:
9  *
10  *              1. Redistributions of source code must retain the above copyright notice,
11  *                 this list of conditions and the following disclaimer.   
12  *              2. Redistributions in binary form must reproduce the above copyright notice,
13  *                 this list of conditions and the following disclaimer in the documentation
14  *                 and/or other materials provided with the distribution.
15  *
16  *      THIS SOFTWARE IS PROVIDED BY PORCHDOG SOFTWARE ``AS IS'' AND ANY
17  *      EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18  *      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19  *      IN NO EVENT SHALL THE HOWL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
20  *      INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21  *      BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22  *      DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  *      OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
24  *      OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
25  *      OF THE POSSIBILITY OF SUCH DAMAGE.
26  *
27  *      The views and conclusions contained in the software and documentation are those
28  *      of the authors and should not be interpreted as representing official policies,
29  *      either expressed or implied, of Porchdog Software.
30  */
31
32 #include <salt/salt.h>
33 #include <salt/socket.h>
34
35
36 #if defined(__cplusplus)
37 extern "C"
38 {
39 #endif
40
41
42 struct                                                                  _sw_discovery;
43 typedef struct _sw_discovery    *       sw_discovery;
44
45
46 /*
47  * keeps track of different discovery operations
48  */
49 typedef sw_uint32                                               sw_discovery_oid;
50
51
52 /*
53  * For backwards compatibility
54  */
55 #define sw_discovery_publish_host_id    sw_discovery_oid        
56 #define sw_discovery_publish_id                 sw_discovery_oid
57 #define sw_discovery_browse_id                  sw_discovery_oid
58 #define sw_discovery_resolve_id                 sw_discovery_oid
59
60
61 /*
62  * how to connect to server
63  */
64 typedef enum _sw_discovery_init_flags
65 {
66         SW_DISCOVERY_USE_SHARED_SERVICE         =       0x1,
67         SW_DISCOVERY_USE_PRIVATE_SERVICE                =       0x2,
68         SW_DISCOVERY_SKIP_VERSION_CHECK         =       0x4
69 } sw_discovery_init_flags;
70
71
72 /*
73  * status for asynchronous registration call
74  */
75 typedef enum _sw_discovery_publish_status
76 {
77         SW_DISCOVERY_PUBLISH_STARTED,
78         SW_DISCOVERY_PUBLISH_STOPPED,
79         SW_DISCOVERY_PUBLISH_NAME_COLLISION,
80         SW_DISCOVERY_PUBLISH_INVALID
81 } sw_discovery_publish_status;
82
83
84 typedef enum _sw_discovery_browse_status
85 {
86         SW_DISCOVERY_BROWSE_INVALID,
87         SW_DISCOVERY_BROWSE_RELEASE,
88         SW_DISCOVERY_BROWSE_ADD_DOMAIN,
89         SW_DISCOVERY_BROWSE_ADD_DEFAULT_DOMAIN,
90         SW_DISCOVERY_BROWSE_REMOVE_DOMAIN,
91         SW_DISCOVERY_BROWSE_ADD_SERVICE,
92         SW_DISCOVERY_BROWSE_REMOVE_SERVICE,
93         SW_DISCOVERY_BROWSE_RESOLVED
94 } sw_discovery_browse_status;
95
96
97 typedef enum _sw_discovery_query_record_status
98 {
99         SW_DISCOVERY_QUERY_RECORD_ADD                   =       0x1
100 } sw_discovery_query_record_status;
101
102
103 typedef sw_result
104 (HOWL_API *sw_discovery_publish_reply)(
105                                                         sw_discovery                                            session,
106                                                         sw_discovery_oid                                        oid,
107                                                         sw_discovery_publish_status     status,
108                                                         sw_opaque                                                       extra);
109
110 typedef sw_result       
111 (HOWL_API *sw_discovery_browse_reply)(
112                                                         sw_discovery                                            session,
113                                                         sw_discovery_oid                                        oid,
114                                                         sw_discovery_browse_status              status,
115                                                         sw_uint32                                                       interface_index,
116                                                         sw_const_string                                 name,
117                                                         sw_const_string                                 type,
118                                                         sw_const_string                                 domain,
119                                                         sw_opaque                                                       extra);
120
121 typedef sw_result
122 (HOWL_API *sw_discovery_resolve_reply)(
123                                                         sw_discovery                                            session,
124                                                         sw_discovery_oid                                        oid,
125                                                         sw_uint32                                                       interface_index,
126                                                         sw_const_string                                 name,
127                                                         sw_const_string                                 type,
128                                                         sw_const_string                                 domain,
129                                                         sw_ipv4_address                                 address,
130                                                         sw_port                                                         port,
131                                                         sw_octets                                                       text_record,
132                                                         sw_uint32                                                       text_record_len,
133                                                         sw_opaque                                                       extra);
134
135
136 typedef sw_result
137 (HOWL_API *sw_discovery_query_record_reply)(
138                                                         sw_discovery                                                            session,
139                                                         sw_discovery_oid                                                        oid,
140                                                         sw_discovery_query_record_status                status,
141                                                         sw_uint32                                                                       interface_index,
142                                                         sw_const_string                                                 fullname,
143                                                         sw_uint16                                                                       rrtype,
144                                                         sw_uint16                                                                       rrclass,
145                                                         sw_uint16                                                                       rrdatalen,      
146                                                         sw_const_octets                                                 rrdata,
147                                                         sw_uint32                                                                       ttl,
148                                                         sw_opaque                                                                       extra); 
149
150
151 /*
152  * API for publishing/browsing/resolving services
153  */
154 sw_result HOWL_API
155 sw_discovery_init(
156                                         sw_discovery                    *       self);
157
158
159 sw_result HOWL_API
160 sw_discovery_init_with_flags(
161                                         sw_discovery                    *       self,
162                                         sw_discovery_init_flags flags);
163
164
165 sw_result HOWL_API
166 sw_discovery_fina(
167                                         sw_discovery            self);
168
169
170 sw_result HOWL_API
171 sw_discovery_publish_host(
172                                         sw_discovery                                            self,
173                                         sw_uint32                                                       interface_index,
174                                         sw_const_string                                 name,
175                                         sw_const_string                                 domain,
176                                         sw_ipv4_address                                 address,
177                                         sw_discovery_publish_reply              reply,
178                                         sw_opaque                                                       extra,
179                                         sw_discovery_oid                                *       oid);
180
181
182 sw_result HOWL_API
183 sw_discovery_publish(
184                                         sw_discovery                                            self,
185                                         sw_uint32                                                       interface_index,
186                                         sw_const_string                                 name,
187                                         sw_const_string                                 type,
188                                         sw_const_string                                 domain,
189                                         sw_const_string                                 host,
190                                         sw_port                                                         port,
191                                         sw_octets                                                       text_record,
192                                         sw_uint32                                                       text_record_len,
193                                         sw_discovery_publish_reply              reply,
194                                         sw_opaque                                                       extra,
195                                         sw_discovery_oid                                *       oid);
196
197
198 sw_result HOWL_API
199 sw_discovery_publish_update(
200                                         sw_discovery                                            self,
201                                         sw_discovery_oid                                        oid,
202                                         sw_octets                                                       text_record,
203                                         sw_uint32                                                       text_record_len);
204
205
206
207 /*
208  * API for browsing domains
209  */
210 sw_result HOWL_API
211 sw_discovery_browse_domains(
212                                         sw_discovery                                            self,
213                                         sw_uint32                                                       interface_index,
214                                         sw_discovery_browse_reply               reply,
215                                         sw_opaque                                                       extra,
216                                         sw_discovery_oid                                *       oid);
217
218
219
220 /*
221  * API for browsing services
222  */
223 sw_result HOWL_API
224 sw_discovery_browse(
225                                         sw_discovery                                            self,
226                                         sw_uint32                                                       interface_index,
227                                         sw_const_string                                 type,
228                                         sw_const_string                                 domain,
229                                         sw_discovery_browse_reply               reply,
230                                         sw_opaque                                                       extra,
231                                         sw_discovery_oid                                *       oid);
232
233
234 /*
235  * API for resolving services
236  */
237 sw_result HOWL_API
238 sw_discovery_resolve(
239                                         sw_discovery                                            self,
240                                         sw_uint32                                                       interface_index,
241                                         sw_const_string                                 name,
242                                         sw_const_string                                 type,
243                                         sw_const_string                                 domain,
244                                         sw_discovery_resolve_reply              reply,
245                                         sw_opaque                                                       extra,
246                                         sw_discovery_oid                                *       oid);
247
248
249 sw_result HOWL_API
250 sw_discovery_query_record(
251                                         sw_discovery                                                            self,
252                                         sw_uint32                                                                       interface_index,
253                                         sw_uint32                                                                       flags,
254                                         sw_const_string                                                 fullname,
255                                         sw_uint16                                                                       rrtype,
256                                         sw_uint16                                                                       rrclass,
257                                         sw_discovery_query_record_reply         reply,  
258                                         sw_opaque                                                                       extra,
259                                         sw_discovery_oid                                                *       oid);
260
261
262 sw_result HOWL_API
263 sw_discovery_cancel(
264                                         sw_discovery            self,
265                                         sw_discovery_oid        oid);
266                                 
267
268
269 /* ----------------------------------------------------------
270  *
271  * Event Processing APIs
272  *
273  * ----------------------------------------------------------
274  */
275                                                 
276
277 sw_result HOWL_API
278 sw_discovery_run(
279                                         sw_discovery                                            self);
280
281
282 sw_result HOWL_API
283 sw_discovery_stop_run(
284                                         sw_discovery                                            self);
285                                                 
286
287 int HOWL_API
288 sw_discovery_socket(
289                                         sw_discovery                                            self);
290
291
292 sw_result HOWL_API
293 sw_discovery_read_socket(
294                                         sw_discovery                                            self);
295
296
297 sw_result HOWL_API
298 sw_discovery_salt(
299                                         sw_discovery    self,
300                                         sw_salt         *       salt);
301
302
303 /*
304  * Error codes
305  */
306 #define SW_DISCOVERY_E_BASE                                     900
307 #define SW_DISCOVERY_E_UNKNOWN                          (SW_DISCOVERY_E_BASE + 2)
308 #define SW_DISCOVERY_E_NO_SUCH_NAME                     (SW_DISCOVERY_E_BASE + 3)
309 #define SW_DISCOVERY_E_NO_MEM                                   (SW_DISCOVERY_E_BASE + 4)
310 #define SW_DISCOVERY_E_BAD_PARAM                                (SW_DISCOVERY_E_BASE + 5)
311 #define SW_DISCOVERY_E_BAD_REFERENCE            (SW_DISCOVERY_E_BASE + 6)
312 #define SW_DISCOVERY_E_BAD_STATE                                (SW_DISCOVERY_E_BASE + 7)
313 #define SW_DISCOVERY_E_BAD_FLAGS                                (SW_DISCOVERY_E_BASE + 8)
314 #define SW_DISCOVERY_E_NOT_SUPPORTED            (SW_DISCOVERY_E_BASE + 9)
315 #define SW_DISCOVERY_E_NOT_INITIALIZED          (SW_DISCOVERY_E_BASE + 10)
316 #define SW_DISCOVERY_E_NO_CACHE                         (SW_DISCOVERY_E_BASE + 11)
317 #define SW_DISCOVERY_E_ALREADY_REGISTERED       (SW_DISCOVERY_E_BASE + 12)
318 #define SW_DISCOVERY_E_NAME_CONFLICT            (SW_DISCOVERY_E_BASE + 13)
319 #define SW_DISCOVERY_E_INVALID                          (SW_DISCOVERY_E_BASE + 14)
320
321
322 #if defined(__cplusplus)
323 }
324 #endif
325
326
327 #endif