]> git.meshlink.io Git - catta/blob - avahi-compat-howl/include/salt/salt.h
add updated specs to svn
[catta] / avahi-compat-howl / include / salt / salt.h
1 #ifndef _sw_salt_h
2 #define _sw_salt_h
3
4 /*
5  * Copyright 2003, 2004 Porchdog Software, Inc. 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, Inc.
30  */
31
32 #include <salt/platform.h>
33 #include <salt/time.h>
34
35
36 #ifdef __cplusplus
37 extern "C"
38 {
39 #endif 
40
41
42 typedef enum _sw_socket_event
43 {
44         SW_SOCKET_READ          =       (1 << 0),
45         SW_SOCKET_WRITE =       (1 << 1),
46         SW_SOCKET_OOB           =       (1 << 2)        
47 } sw_socket_event;
48
49
50 struct                                                  _sw_salt;
51 typedef struct _sw_salt *       sw_salt;
52 struct                                                  _sw_socket;
53 struct                                                  _sw_timer;
54 struct                                                  _sw_network_interface;
55 struct                                                  _sw_signal;
56
57 typedef sw_opaque                               sw_socket_handler;
58 typedef sw_result
59 (HOWL_API *sw_socket_handler_func)(
60                                                                         sw_socket_handler               handler,
61                                                                         sw_salt                                 salt,
62                                                                         struct _sw_socket       *       socket,
63                                                                         sw_socket_event         events,
64                                                                         sw_opaque                               extra);
65
66
67 typedef sw_opaque                               sw_timer_handler;
68 typedef sw_result
69 (HOWL_API *sw_timer_handler_func)(
70                                                                         sw_timer_handler                handler,
71                                                                         sw_salt                                 salt,
72                                                                         struct _sw_timer        *       timer,
73                                                                         sw_time                                 timeout,
74                                                                         sw_opaque                               extra);
75
76 typedef sw_opaque                               sw_network_interface_handler;
77 typedef sw_result
78 (HOWL_API *sw_network_interface_handler_func)(
79                                                                         sw_network_interface_handler            handler,
80                                                                         sw_salt                                                                 salt,
81                                                                         struct _sw_network_interface    *       netif,
82                                                                         sw_opaque                                                               extra);
83                 
84 typedef sw_opaque                               sw_signal_handler;
85 typedef sw_result
86 (HOWL_API *sw_signal_handler_func)(
87                                                                         sw_signal_handler               handler,
88                                                                         sw_salt                                 salt,
89                                                                         struct _sw_signal       *       signal,
90                                                                         sw_opaque                               extra);
91
92
93 sw_result HOWL_API
94 sw_salt_init(
95                                 sw_salt         *       self,
96                                 int                             argc,
97                                 char                    **      argv);
98                                  
99                                  
100 sw_result HOWL_API
101 sw_salt_fina(
102                                 sw_salt self);
103
104                                                                   
105 sw_result HOWL_API
106 sw_salt_register_socket(
107                                 sw_salt                                         self,
108                                 struct _sw_socket               *       socket,
109                                 sw_socket_event                 events,
110                                 sw_socket_handler                       handler,
111                                 sw_socket_handler_func  func,
112                                 sw_opaque                                       extra);
113
114
115 sw_result HOWL_API
116 sw_salt_unregister_socket(
117                                 sw_salt                                         self,
118                                 struct _sw_socket               *       socket);
119                                  
120                                  
121 sw_result HOWL_API
122 sw_salt_register_timer(
123                                 sw_salt                                         self,
124                                 struct _sw_timer                *       timer,
125                                 sw_time                                         timeout,
126                                 sw_timer_handler                        handler,
127                                 sw_timer_handler_func   func,
128                                 sw_opaque                                       extra);
129                                  
130                                  
131 sw_result HOWL_API
132 sw_salt_unregister_timer(
133                                 sw_salt                                         self,
134                                 struct _sw_timer                *       timer);
135
136
137 sw_result HOWL_API
138 sw_salt_register_network_interface(
139                                 sw_salt                                                                         self,
140                                 struct _sw_network_interface            *       netif,
141                                 sw_network_interface_handler                    handler,
142                                 sw_network_interface_handler_func       func,
143                                 sw_opaque                                                                       extra);
144
145
146 sw_result HOWL_API
147 sw_salt_unregister_network_interface_handler(
148                                 sw_salt                                         self);
149
150
151 sw_result HOWL_API
152 sw_salt_register_signal(
153                                 sw_salt                                         self,
154                                 struct _sw_signal       *               signal,
155                                 sw_signal_handler                       handler,
156                                 sw_signal_handler_func  func,
157                                 sw_opaque                                       extra);
158
159
160 sw_result HOWL_API
161 sw_salt_unregister_signal(
162                                 sw_salt                                         self,
163                                 struct _sw_signal       *               signal);
164
165
166 sw_result HOWL_API
167 sw_salt_lock(
168                                 sw_salt self);
169
170
171 sw_result HOWL_API
172 sw_salt_unlock(
173                                 sw_salt self);
174
175
176 sw_result HOWL_API
177 sw_salt_step(
178                                 sw_salt         self,
179                                 sw_uint32       *       msec);
180
181
182 sw_result HOWL_API
183 sw_salt_run(
184                                 sw_salt self);
185
186
187 sw_result HOWL_API
188 sw_salt_stop_run(
189                                 sw_salt self);
190             
191
192 #define SW_FALSE                0
193 #define SW_TRUE         1
194 #define SW_OKAY         0
195
196
197 /*
198  * error codes
199  */
200 #define SW_E_CORE_BASE                                  0x80000000
201 #define SW_E_UNKNOWN                                    (SW_E_CORE_BASE) + 1
202 #define SW_E_INIT                                               (SW_E_CORE_BASE) + 2
203 #define SW_E_MEM                                                        (SW_E_CORE_BASE) + 3
204 #define SW_E_EOF                                                        (SW_E_CORE_BASE) + 4
205 #define SW_E_NO_IMPL                                    (SW_E_CORE_BASE) + 5
206 #define SW_E_FILE_LOCKED                                (SW_E_CORE_BASE) + 6
207 #define SW_E_PROTOCOL_NOT_FOUND         (SW_E_CORE_BASE) + 7
208
209
210 #ifdef __cplusplus
211 }
212 #endif
213
214
215 #endif