xref: /freebsd/contrib/openbsm/bin/auditdistd/proto.c (revision f05cddf9) 
1 /*-
2  * Copyright (c) 2009-2010 The FreeBSD Foundation
3  * All rights reserved.
4  *
5  * This software was developed by Pawel Jakub Dawidek under sponsorship from
6  * the FreeBSD Foundation.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $P4: //depot/projects/trustedbsd/openbsm/bin/auditdistd/proto.c#1 $
30  */
31 
32 #include <sys/types.h>
33 #include <sys/queue.h>
34 #include <sys/socket.h>
35 
36 #include <errno.h>
37 #include <stdint.h>
38 #include <string.h>
39 #include <strings.h>
40 
41 #include "pjdlog.h"
42 #include "proto.h"
43 #include "proto_impl.h"
44 
45 #define	PROTO_CONN_MAGIC	0x907041c
46 struct proto_conn {
47 	int		 pc_magic;
48 	struct proto	*pc_proto;
49 	void		*pc_ctx;
50 	int		 pc_side;
51 #define	PROTO_SIDE_CLIENT		0
52 #define	PROTO_SIDE_SERVER_LISTEN	1
53 #define	PROTO_SIDE_SERVER_WORK		2
54 };
55 
56 static TAILQ_HEAD(, proto) protos = TAILQ_HEAD_INITIALIZER(protos);
57 
58 void
59 proto_register(struct proto *proto, bool isdefault)
60 {
61 	static bool seen_default = false;
62 
63 	if (!isdefault)
64 		TAILQ_INSERT_HEAD(&protos, proto, prt_next);
65 	else {
66 		PJDLOG_ASSERT(!seen_default);
67 		seen_default = true;
68 		TAILQ_INSERT_TAIL(&protos, proto, prt_next);
69 	}
70 }
71 
72 static struct proto_conn *
73 proto_alloc(struct proto *proto, int side)
74 {
75 	struct proto_conn *conn;
76 
77 	PJDLOG_ASSERT(proto != NULL);
78 	PJDLOG_ASSERT(side == PROTO_SIDE_CLIENT ||
79 	    side == PROTO_SIDE_SERVER_LISTEN ||
80 	    side == PROTO_SIDE_SERVER_WORK);
81 
82 	conn = malloc(sizeof(*conn));
83 	if (conn != NULL) {
84 		conn->pc_proto = proto;
85 		conn->pc_side = side;
86 		conn->pc_magic = PROTO_CONN_MAGIC;
87 	}
88 	return (conn);
89 }
90 
91 static void
92 proto_free(struct proto_conn *conn)
93 {
94 
95 	PJDLOG_ASSERT(conn != NULL);
96 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
97 	PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_CLIENT ||
98 	    conn->pc_side == PROTO_SIDE_SERVER_LISTEN ||
99 	    conn->pc_side == PROTO_SIDE_SERVER_WORK);
100 	PJDLOG_ASSERT(conn->pc_proto != NULL);
101 
102 	bzero(conn, sizeof(*conn));
103 	free(conn);
104 }
105 
106 static int
107 proto_common_setup(const char *srcaddr, const char *dstaddr, int timeout,
108     int side, struct proto_conn **connp)
109 {
110 	struct proto *proto;
111 	struct proto_conn *conn;
112 	void *ctx;
113 	int ret;
114 
115 	PJDLOG_ASSERT(side == PROTO_SIDE_CLIENT ||
116 	    side == PROTO_SIDE_SERVER_LISTEN);
117 
118 	TAILQ_FOREACH(proto, &protos, prt_next) {
119 		if (side == PROTO_SIDE_CLIENT) {
120 			if (proto->prt_connect == NULL) {
121 				ret = -1;
122 			} else {
123 				ret = proto->prt_connect(srcaddr, dstaddr,
124 				    timeout, &ctx);
125 			}
126 		} else /* if (side == PROTO_SIDE_SERVER_LISTEN) */ {
127 			if (proto->prt_server == NULL)
128 				ret = -1;
129 			else
130 				ret = proto->prt_server(dstaddr, &ctx);
131 		}
132 		/*
133 		 * ret == 0  - success
134 		 * ret == -1 - dstaddr is not for this protocol
135 		 * ret > 0   - right protocol, but an error occured
136 		 */
137 		if (ret >= 0)
138 			break;
139 	}
140 	if (proto == NULL) {
141 		/* Unrecognized address. */
142 		errno = EINVAL;
143 		return (-1);
144 	}
145 	if (ret > 0) {
146 		/* An error occured. */
147 		errno = ret;
148 		return (-1);
149 	}
150 	conn = proto_alloc(proto, side);
151 	if (conn == NULL) {
152 		if (proto->prt_close != NULL)
153 			proto->prt_close(ctx);
154 		errno = ENOMEM;
155 		return (-1);
156 	}
157 	conn->pc_ctx = ctx;
158 	*connp = conn;
159 
160 	return (0);
161 }
162 
163 int
164 proto_connect(const char *srcaddr, const char *dstaddr, int timeout,
165     struct proto_conn **connp)
166 {
167 
168 	PJDLOG_ASSERT(srcaddr == NULL || srcaddr[0] != '\0');
169 	PJDLOG_ASSERT(dstaddr != NULL);
170 	PJDLOG_ASSERT(timeout >= -1);
171 
172 	return (proto_common_setup(srcaddr, dstaddr, timeout,
173 	    PROTO_SIDE_CLIENT, connp));
174 }
175 
176 int
177 proto_connect_wait(struct proto_conn *conn, int timeout)
178 {
179 	int error;
180 
181 	PJDLOG_ASSERT(conn != NULL);
182 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
183 	PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_CLIENT);
184 	PJDLOG_ASSERT(conn->pc_proto != NULL);
185 	PJDLOG_ASSERT(conn->pc_proto->prt_connect_wait != NULL);
186 	PJDLOG_ASSERT(timeout >= 0);
187 
188 	error = conn->pc_proto->prt_connect_wait(conn->pc_ctx, timeout);
189 	if (error != 0) {
190 		errno = error;
191 		return (-1);
192 	}
193 
194 	return (0);
195 }
196 
197 int
198 proto_server(const char *addr, struct proto_conn **connp)
199 {
200 
201 	PJDLOG_ASSERT(addr != NULL);
202 
203 	return (proto_common_setup(NULL, addr, -1, PROTO_SIDE_SERVER_LISTEN,
204 	    connp));
205 }
206 
207 int
208 proto_accept(struct proto_conn *conn, struct proto_conn **newconnp)
209 {
210 	struct proto_conn *newconn;
211 	int error;
212 
213 	PJDLOG_ASSERT(conn != NULL);
214 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
215 	PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_SERVER_LISTEN);
216 	PJDLOG_ASSERT(conn->pc_proto != NULL);
217 	PJDLOG_ASSERT(conn->pc_proto->prt_accept != NULL);
218 
219 	newconn = proto_alloc(conn->pc_proto, PROTO_SIDE_SERVER_WORK);
220 	if (newconn == NULL)
221 		return (-1);
222 
223 	error = conn->pc_proto->prt_accept(conn->pc_ctx, &newconn->pc_ctx);
224 	if (error != 0) {
225 		proto_free(newconn);
226 		errno = error;
227 		return (-1);
228 	}
229 
230 	*newconnp = newconn;
231 
232 	return (0);
233 }
234 
235 int
236 proto_send(const struct proto_conn *conn, const void *data, size_t size)
237 {
238 	int error;
239 
240 	PJDLOG_ASSERT(conn != NULL);
241 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
242 	PJDLOG_ASSERT(conn->pc_proto != NULL);
243 	PJDLOG_ASSERT(conn->pc_proto->prt_send != NULL);
244 
245 	error = conn->pc_proto->prt_send(conn->pc_ctx, data, size, -1);
246 	if (error != 0) {
247 		errno = error;
248 		return (-1);
249 	}
250 	return (0);
251 }
252 
253 int
254 proto_recv(const struct proto_conn *conn, void *data, size_t size)
255 {
256 	int error;
257 
258 	PJDLOG_ASSERT(conn != NULL);
259 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
260 	PJDLOG_ASSERT(conn->pc_proto != NULL);
261 	PJDLOG_ASSERT(conn->pc_proto->prt_recv != NULL);
262 
263 	error = conn->pc_proto->prt_recv(conn->pc_ctx, data, size, NULL);
264 	if (error != 0) {
265 		errno = error;
266 		return (-1);
267 	}
268 	return (0);
269 }
270 
271 int
272 proto_connection_send(const struct proto_conn *conn, struct proto_conn *mconn)
273 {
274 	const char *protoname;
275 	int error, fd;
276 
277 	PJDLOG_ASSERT(conn != NULL);
278 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
279 	PJDLOG_ASSERT(conn->pc_proto != NULL);
280 	PJDLOG_ASSERT(conn->pc_proto->prt_send != NULL);
281 	PJDLOG_ASSERT(mconn != NULL);
282 	PJDLOG_ASSERT(mconn->pc_magic == PROTO_CONN_MAGIC);
283 	PJDLOG_ASSERT(mconn->pc_proto != NULL);
284 	fd = proto_descriptor(mconn);
285 	PJDLOG_ASSERT(fd >= 0);
286 	protoname = mconn->pc_proto->prt_name;
287 	PJDLOG_ASSERT(protoname != NULL);
288 
289 	error = conn->pc_proto->prt_send(conn->pc_ctx,
290 	    (const unsigned char *)protoname, strlen(protoname) + 1, fd);
291 	proto_close(mconn);
292 	if (error != 0) {
293 		errno = error;
294 		return (-1);
295 	}
296 	return (0);
297 }
298 
299 int
300 proto_wrap(const char *protoname, bool client, int fd,
301     struct proto_conn **newconnp)
302 {
303 	struct proto *proto;
304 	struct proto_conn *newconn;
305 	int error;
306 
307 	TAILQ_FOREACH(proto, &protos, prt_next) {
308 		if (strcmp(proto->prt_name, protoname) == 0)
309 			break;
310 	}
311 	if (proto == NULL) {
312 		errno = EINVAL;
313 		return (-1);
314 	}
315 
316 	newconn = proto_alloc(proto,
317 	    client ? PROTO_SIDE_CLIENT : PROTO_SIDE_SERVER_WORK);
318 	if (newconn == NULL)
319 		return (-1);
320 	PJDLOG_ASSERT(newconn->pc_proto->prt_wrap != NULL);
321 	error = newconn->pc_proto->prt_wrap(fd, client, &newconn->pc_ctx);
322 	if (error != 0) {
323 		proto_free(newconn);
324 		errno = error;
325 		return (-1);
326 	}
327 
328 	*newconnp = newconn;
329 
330 	return (0);
331 }
332 
333 int
334 proto_connection_recv(const struct proto_conn *conn, bool client,
335     struct proto_conn **newconnp)
336 {
337 	char protoname[128];
338 	int error, fd;
339 
340 	PJDLOG_ASSERT(conn != NULL);
341 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
342 	PJDLOG_ASSERT(conn->pc_proto != NULL);
343 	PJDLOG_ASSERT(conn->pc_proto->prt_recv != NULL);
344 	PJDLOG_ASSERT(newconnp != NULL);
345 
346 	bzero(protoname, sizeof(protoname));
347 
348 	error = conn->pc_proto->prt_recv(conn->pc_ctx,
349 	    (unsigned char *)protoname, sizeof(protoname) - 1, &fd);
350 	if (error != 0) {
351 		errno = error;
352 		return (-1);
353 	}
354 
355 	PJDLOG_ASSERT(fd >= 0);
356 
357 	return (proto_wrap(protoname, client, fd, newconnp));
358 }
359 
360 int
361 proto_descriptor(const struct proto_conn *conn)
362 {
363 
364 	PJDLOG_ASSERT(conn != NULL);
365 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
366 	PJDLOG_ASSERT(conn->pc_proto != NULL);
367 	PJDLOG_ASSERT(conn->pc_proto->prt_descriptor != NULL);
368 
369 	return (conn->pc_proto->prt_descriptor(conn->pc_ctx));
370 }
371 
372 bool
373 proto_address_match(const struct proto_conn *conn, const char *addr)
374 {
375 
376 	PJDLOG_ASSERT(conn != NULL);
377 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
378 	PJDLOG_ASSERT(conn->pc_proto != NULL);
379 	PJDLOG_ASSERT(conn->pc_proto->prt_address_match != NULL);
380 
381 	return (conn->pc_proto->prt_address_match(conn->pc_ctx, addr));
382 }
383 
384 void
385 proto_local_address(const struct proto_conn *conn, char *addr, size_t size)
386 {
387 
388 	PJDLOG_ASSERT(conn != NULL);
389 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
390 	PJDLOG_ASSERT(conn->pc_proto != NULL);
391 	PJDLOG_ASSERT(conn->pc_proto->prt_local_address != NULL);
392 
393 	conn->pc_proto->prt_local_address(conn->pc_ctx, addr, size);
394 }
395 
396 void
397 proto_remote_address(const struct proto_conn *conn, char *addr, size_t size)
398 {
399 
400 	PJDLOG_ASSERT(conn != NULL);
401 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
402 	PJDLOG_ASSERT(conn->pc_proto != NULL);
403 	PJDLOG_ASSERT(conn->pc_proto->prt_remote_address != NULL);
404 
405 	conn->pc_proto->prt_remote_address(conn->pc_ctx, addr, size);
406 }
407 
408 int
409 proto_timeout(const struct proto_conn *conn, int timeout)
410 {
411 	struct timeval tv;
412 	int fd;
413 
414 	PJDLOG_ASSERT(conn != NULL);
415 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
416 	PJDLOG_ASSERT(conn->pc_proto != NULL);
417 
418 	fd = proto_descriptor(conn);
419 	if (fd < 0)
420 		return (-1);
421 
422 	tv.tv_sec = timeout;
423 	tv.tv_usec = 0;
424 	if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
425 		return (-1);
426 	if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0)
427 		return (-1);
428 
429 	return (0);
430 }
431 
432 void
433 proto_close(struct proto_conn *conn)
434 {
435 
436 	PJDLOG_ASSERT(conn != NULL);
437 	PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
438 	PJDLOG_ASSERT(conn->pc_proto != NULL);
439 	PJDLOG_ASSERT(conn->pc_proto->prt_close != NULL);
440 
441 	conn->pc_proto->prt_close(conn->pc_ctx);
442 	proto_free(conn);
443 }
444 
445 int
446 proto_exec(int argc, char *argv[])
447 {
448 	struct proto *proto;
449 	int error;
450 
451 	if (argc == 0) {
452 		errno = EINVAL;
453 		return (-1);
454 	}
455 	TAILQ_FOREACH(proto, &protos, prt_next) {
456 		if (strcmp(proto->prt_name, argv[0]) == 0)
457 			break;
458 	}
459 	if (proto == NULL) {
460 		errno = EINVAL;
461 		return (-1);
462 	}
463 	if (proto->prt_exec == NULL) {
464 		errno = EOPNOTSUPP;
465 		return (-1);
466 	}
467 	error = proto->prt_exec(argc, argv);
468 	if (error != 0) {
469 		errno = error;
470 		return (-1);
471 	}
472 	/* NOTREACHED */
473 	return (0);
474 }
475 
476 struct proto_nvpair {
477 	char	*pnv_name;
478 	char	*pnv_value;
479 	TAILQ_ENTRY(proto_nvpair) pnv_next;
480 };
481 
482 static TAILQ_HEAD(, proto_nvpair) proto_nvpairs =
483     TAILQ_HEAD_INITIALIZER(proto_nvpairs);
484 
485 int
486 proto_set(const char *name, const char *value)
487 {
488 	struct proto_nvpair *pnv;
489 
490 	TAILQ_FOREACH(pnv, &proto_nvpairs, pnv_next) {
491 		if (strcmp(pnv->pnv_name, name) == 0)
492 			break;
493 	}
494 	if (pnv != NULL) {
495 		TAILQ_REMOVE(&proto_nvpairs, pnv, pnv_next);
496 		free(pnv->pnv_value);
497 	} else {
498 		pnv = malloc(sizeof(*pnv));
499 		if (pnv == NULL)
500 			return (-1);
501 		pnv->pnv_name = strdup(name);
502 		if (pnv->pnv_name == NULL) {
503 			free(pnv);
504 			return (-1);
505 		}
506 	}
507 	pnv->pnv_value = strdup(value);
508 	if (pnv->pnv_value == NULL) {
509 		free(pnv->pnv_name);
510 		free(pnv);
511 		return (-1);
512 	}
513 	TAILQ_INSERT_TAIL(&proto_nvpairs, pnv, pnv_next);
514 	return (0);
515 }
516 
517 const char *
518 proto_get(const char *name)
519 {
520 	struct proto_nvpair *pnv;
521 
522 	TAILQ_FOREACH(pnv, &proto_nvpairs, pnv_next) {
523 		if (strcmp(pnv->pnv_name, name) == 0)
524 			break;
525 	}
526 	if (pnv != NULL)
527 		return (pnv->pnv_value);
528 	return (NULL);
529 }
530