2 * Amanda, The Advanced Maryland Automatic Network Disk Archiver
3 * Copyright (c) 1999 University of Maryland at College Park
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of U.M. not be used in advertising or
11 * publicity pertaining to distribution of the software without specific,
12 * written prior permission. U.M. makes no representations about the
13 * suitability of this software for any purpose. It is provided "as is"
14 * without express or implied warranty.
16 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
18 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
20 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 * Authors: the Amanda Development Team. Its members are listed in a
24 * file named AUTHORS, in the root directory of this distribution.
27 * $Id: security.h,v 1.17 2006/05/26 14:00:58 martinea Exp $
36 struct security_handle;
39 * This is a type that gets passed to the security_recvpkt() and
40 * security_connect() callbacks.
41 * It details what the status of this callback is.
43 typedef enum { S_OK, S_TIMEOUT, S_ERROR } security_status_t;
46 * This structure defines a security driver. This driver abstracts
47 * common security actions behind a set of function pointers. Macros
50 typedef struct security_driver {
52 * The name of this driver, eg, "BSD", "KRB4", etc...
57 * Connects a security handle, for this driver to a remote
60 void (*connect)(const char *,
61 char *(*)(char *, void *),
62 void (*)(void *, struct security_handle *, security_status_t),
66 * This form sets up a callback that returns new handles as
67 * they are received. It takes an input and output file descriptor.
69 void (*accept)(const struct security_driver *,
70 char *(*)(char *, void *),
72 void (*)(struct security_handle *, pkt_t *),
76 * Frees up handles allocated by the previous
78 void (*close)(void *);
81 * This transmits a packet after adding the security information
82 * Returns 0 on success, negative on error.
84 ssize_t (*sendpkt)(void *, pkt_t *);
87 * This creates an event in the event handler for receiving pkt_t's
88 * on a security_handle. The given callback with the given arg
89 * will be called when the driver determines that it has data
90 * for that handle. The last argument is a timeout, in seconds.
91 * This may be -1 to indicate no timeout.
93 * If there was an error or timeout, this will be indicated in
94 * the status argument.
96 * Only one recvpkt request can exist per handle.
98 void (*recvpkt)(void *, void (*)(void *, pkt_t *,
99 security_status_t), void *, int);
102 * Cancel an outstanding recvpkt request on a handle.
104 void (*recvpkt_cancel)(void *);
107 * Get a stream given a security handle
109 void *(*stream_server)(void *);
112 * Accept a stream created by stream_server
114 int (*stream_accept)(void *);
117 * Get a stream and connect it to a remote given a security handle
120 void *(*stream_client)(void *, int);
123 * Close a stream opened with stream_server or stream_client
125 void (*stream_close)(void *);
128 * Authenticate a stream.
130 int (*stream_auth)(void *);
133 * Return a numeric id for a stream.
135 int (*stream_id)(void *);
140 int (*stream_write)(void *, const void *, size_t);
143 * Read asyncronously from a stream. Only one request can exist
146 void (*stream_read)(void *, void (*)(void *, void *, ssize_t), void *);
149 * Read syncronously from a stream.
151 ssize_t (*stream_read_sync)(void *, void **);
154 * Cancel a stream read request
156 void (*stream_read_cancel)(void *);
158 void (*close_connection)(void *, char *);
160 int (*data_encrypt)(void *, void *, ssize_t, void **, ssize_t *);
161 int (*data_decrypt)(void *, void *, ssize_t, void **, ssize_t *);
165 * This structure is a handle to a connection to a host for transmission
166 * of protocol packets (pkt_t's). The underlying security type defines
167 * the actual protocol and transport.
169 * This handle is reference counted so that it can be used inside of
170 * security streams after it has been closed by our callers.
172 typedef struct security_handle {
173 const security_driver_t *driver;
178 * This structure is a handle to a stream connection to a host for
179 * transmission of random data such as dumps or index data.
181 typedef struct security_stream {
182 const security_driver_t *driver;
187 const security_driver_t *security_getdriver(const char *);
188 void security_handleinit(security_handle_t *, const security_driver_t *);
189 void security_streaminit(security_stream_t *, const security_driver_t *);
191 /* const char *security_geterror(security_handle_t *); */
192 #define security_geterror(handle) ((handle)->error)
193 void security_seterror(security_handle_t *, const char *, ...)
197 /* void security_connect(const security_driver_t *, const char *,
198 char *(*)(char *, void *),
199 void (*)(void *, security_handle_t *, security_status_t),
202 #define security_connect(driver, hostname, conf_fn, fn, arg, datap) \
203 (*(driver)->connect)(hostname, conf_fn, fn, arg, datap)
205 /* void security_accept(const security_driver_t *,
206 char *(*)(char *, void *), int, int,
207 void (*)(security_handle_t *, pkt_t *), void *); */
208 #define security_accept(driver, conf_fn, in, out, fn, datap) \
209 (*(driver)->accept)(driver, conf_fn, in, out, fn, datap)
210 void security_close(security_handle_t *);
212 /* ssize_t security_sendpkt(security_handle_t *, const pkt_t *); */
213 #define security_sendpkt(handle, pkt) \
214 (*(handle)->driver->sendpkt)(handle, pkt)
216 /* void security_recvpkt(security_handle_t *,
217 void (*)(void *, pkt_t *, security_status_t), void *, int); */
218 #define security_recvpkt(handle, fn, arg, timeout) \
219 (*(handle)->driver->recvpkt)(handle, fn, arg, timeout)
221 /* void security_recvpkt_cancel(security_handle_t *); */
222 #define security_recvpkt_cancel(handle) \
223 (*(handle)->driver->recvpkt_cancel)(handle)
225 /* const char *security_stream_geterror(security_stream_t *); */
226 #define security_stream_geterror(stream) ((stream)->error)
227 void security_stream_seterror(security_stream_t *, const char *, ...)
230 /* security_stream_t *security_stream_server(security_handle_t *); */
231 #define security_stream_server(handle) \
232 (*(handle)->driver->stream_server)(handle)
234 /* int security_stream_accept(security_stream_t *); */
235 #define security_stream_accept(stream) \
236 (*(stream)->driver->stream_accept)(stream)
238 /* security_stream_t *security_stream_client(security_handle_t *, int); */
239 #define security_stream_client(handle, id) \
240 (*(handle)->driver->stream_client)(handle, id)
242 void security_stream_close(security_stream_t *);
244 /* int security_stream_auth(security_stream_t *); */
245 #define security_stream_auth(stream) \
246 (*(stream)->driver->stream_auth)(stream)
248 /* int security_stream_id(security_stream_t *); */
249 #define security_stream_id(stream) \
250 (*(stream)->driver->stream_id)(stream)
252 /* int security_stream_write(security_stream_t *, const void *, size_t); */
253 #define security_stream_write(stream, buf, size) \
254 (*(stream)->driver->stream_write)(stream, buf, size)
256 /* void security_stream_read(security_stream_t *,
257 void (*)(void *, void *, size_t), void *); */
258 #define security_stream_read(stream, fn, arg) \
259 (*(stream)->driver->stream_read)(stream, fn, arg)
261 /* void security_stream_read_sync(security_stream_t *, void *); */
262 #define security_stream_read_sync(stream, buf) \
263 (*(stream)->driver->stream_read_sync)(stream, buf)
265 /* void security_stream_read_cancel(security_stream_t *); */
266 #define security_stream_read_cancel(stream) \
267 (*(stream)->driver->stream_read_cancel)(stream)
269 #define security_close_connection(handle, hostname) \
270 (*(handle)->driver->close_connection)(handle, hostname)
271 #endif /* SECURITY_H */