xref: /freebsd/contrib/bsnmp/snmpd/trans_lsock.c (revision 3642298923e528d795e3a30ec165d2b469e28b40) 
1 /*
2  * Copyright (c) 2003
3  *	Fraunhofer Institute for Open Communication Systems (FhG Fokus).
4  *	All rights reserved.
5  *
6  * Author: Harti Brandt <harti@freebsd.org>
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 AUTHOR 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 AUTHOR 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  * $Begemot: bsnmp/snmpd/trans_lsock.c,v 1.6 2005/02/25 11:50:25 brandt_h Exp $
30  *
31  * Local domain socket transport
32  */
33 #include <sys/types.h>
34 #include <sys/un.h>
35 #include <sys/stat.h>
36 
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <stddef.h>
40 #include <syslog.h>
41 #include <string.h>
42 #include <errno.h>
43 #include <unistd.h>
44 
45 #include "snmpmod.h"
46 #include "snmpd.h"
47 #include "trans_lsock.h"
48 #include "tree.h"
49 #include "oid.h"
50 
51 static const struct asn_oid
52 	oid_begemotSnmpdLocalPortTable = OIDX_begemotSnmpdLocalPortTable;
53 
54 static int lsock_start(void);
55 static int lsock_stop(int);
56 static void lsock_close_port(struct tport *);
57 static int lsock_init_port(struct tport *);
58 static ssize_t lsock_send(struct tport *, const u_char *, size_t,
59     const struct sockaddr *, size_t);
60 
61 /* exported */
62 const struct transport_def lsock_trans = {
63 	"lsock",
64 	OIDX_begemotSnmpdTransLsock,
65 	lsock_start,
66 	lsock_stop,
67 	lsock_close_port,
68 	lsock_init_port,
69 	lsock_send
70 };
71 static struct transport *my_trans;
72 
73 static int
74 lsock_remove(struct tport *tp, intptr_t arg __unused)
75 {
76 	struct lsock_port *port = (struct lsock_port *)tp;
77 
78 	(void)remove(port->name);
79 
80 	return (-1);
81 }
82 
83 static int
84 lsock_stop(int force)
85 {
86 
87 	if (my_trans != NULL) {
88 		if (!force && trans_first_port(my_trans) != NULL)
89 			return (SNMP_ERR_GENERR);
90 		trans_iter_port(my_trans, lsock_remove, 0);
91 		return (trans_unregister(my_trans));
92 	}
93 	return (SNMP_ERR_NOERROR);
94 }
95 
96 static int
97 lsock_start(void)
98 {
99 	return (trans_register(&lsock_trans, &my_trans));
100 }
101 
102 /*
103  * Open a local port. If this is a datagram socket create also the
104  * one and only peer.
105  */
106 static int
107 lsock_open_port(u_char *name, size_t namelen, struct lsock_port **pp,
108     int type)
109 {
110 	struct lsock_port *port;
111 	struct lsock_peer *peer = NULL;
112 	int is_stream, need_cred;
113 	size_t u;
114 	int err;
115 	struct sockaddr_un sa;
116 
117 	if (namelen == 0 || namelen + 1 > sizeof(sa.sun_path))
118 		return (SNMP_ERR_BADVALUE);
119 
120 	switch (type) {
121 	  case LOCP_DGRAM_UNPRIV:
122 		is_stream = 0;
123 		need_cred = 0;
124 		break;
125 
126 	  case LOCP_DGRAM_PRIV:
127 		is_stream = 0;
128 		need_cred = 1;
129 		break;
130 
131 	  case LOCP_STREAM_UNPRIV:
132 		is_stream = 1;
133 		need_cred = 0;
134 		break;
135 
136 	  case LOCP_STREAM_PRIV:
137 		is_stream = 1;
138 		need_cred = 1;
139 		break;
140 
141 	  default:
142 		return (SNMP_ERR_BADVALUE);
143 	}
144 
145 	if ((port = malloc(sizeof(*port))) == NULL)
146 		return (SNMP_ERR_GENERR);
147 
148 	memset(port, 0, sizeof(*port));
149 	if (!is_stream) {
150 		if ((peer = malloc(sizeof(*peer))) == NULL) {
151 			free(port);
152 			return (SNMP_ERR_GENERR);
153 		}
154 		memset(peer, 0, sizeof(*peer));
155 	}
156 	if ((port->name = malloc(namelen + 1)) == NULL) {
157 		free(port);
158 		if (!is_stream)
159 			free(peer);
160 		return (SNMP_ERR_GENERR);
161 	}
162 	strncpy(port->name, name, namelen);
163 	port->name[namelen] = '\0';
164 
165 	port->type = type;
166 	port->str_sock = -1;
167 	LIST_INIT(&port->peers);
168 
169 	port->tport.index.len = namelen + 1;
170 	port->tport.index.subs[0] = namelen;
171 	for (u = 0; u < namelen; u++)
172 		port->tport.index.subs[u + 1] = name[u];
173 
174 	if (peer != NULL) {
175 		LIST_INSERT_HEAD(&port->peers, peer, link);
176 
177 		peer->port = port;
178 
179 		peer->input.fd = -1;
180 		peer->input.id = NULL;
181 		peer->input.stream = is_stream;
182 		peer->input.cred = need_cred;
183 		peer->input.peer = (struct sockaddr *)&peer->peer;
184 	}
185 
186 	trans_insert_port(my_trans, &port->tport);
187 
188 	if (community != COMM_INITIALIZE &&
189 	    (err = lsock_init_port(&port->tport)) != SNMP_ERR_NOERROR) {
190 		lsock_close_port(&port->tport);
191 		return (err);
192 	}
193 
194 	*pp = port;
195 
196 	return (SNMP_ERR_NOERROR);
197 }
198 
199 /*
200  * Close a local domain peer
201  */
202 static void
203 lsock_peer_close(struct lsock_peer *peer)
204 {
205 
206 	LIST_REMOVE(peer, link);
207 	snmpd_input_close(&peer->input);
208 	free(peer);
209 }
210 
211 /*
212  * Close a local port
213  */
214 static void
215 lsock_close_port(struct tport *tp)
216 {
217 	struct lsock_port *port = (struct lsock_port *)tp;
218 	struct lsock_peer *peer;
219 
220 	if (port->str_id != NULL)
221 		fd_deselect(port->str_id);
222 	if (port->str_sock >= 0)
223 		(void)close(port->str_sock);
224 	(void)remove(port->name);
225 
226 	trans_remove_port(tp);
227 
228 	while ((peer = LIST_FIRST(&port->peers)) != NULL)
229 		lsock_peer_close(peer);
230 
231 	free(port->name);
232 	free(port);
233 }
234 
235 /*
236  * Input on a local socket (either datagram or stream)
237  */
238 static void
239 lsock_input(int fd __unused, void *udata)
240 {
241 	struct lsock_peer *peer = udata;
242 	struct lsock_port *p = peer->port;
243 
244 	peer->input.peerlen = sizeof(peer->peer);
245 	if (snmpd_input(&peer->input, &p->tport) == -1 && peer->input.stream)
246 		/* framing or other input error */
247 		lsock_peer_close(peer);
248 }
249 
250 /*
251  * A UNIX domain listening socket is ready. This means we have a peer
252  * that we need to accept
253  */
254 static void
255 lsock_listen_input(int fd, void *udata)
256 {
257 	struct lsock_port *p = udata;
258 	struct lsock_peer *peer;
259 
260 	if ((peer = malloc(sizeof(*peer))) == NULL) {
261 		syslog(LOG_WARNING, "%s: peer malloc failed", p->name);
262 		(void)close(accept(fd, NULL, NULL));
263 		return;
264 	}
265 	memset(peer, 0, sizeof(*peer));
266 
267 	peer->port = p;
268 
269 	peer->input.stream = 1;
270 	peer->input.cred = (p->type == LOCP_DGRAM_PRIV ||
271 	    p->type == LOCP_STREAM_PRIV);
272 	peer->input.peerlen = sizeof(peer->peer);
273 	peer->input.peer = (struct sockaddr *)&peer->peer;
274 
275 	peer->input.fd = accept(fd, peer->input.peer, &peer->input.peerlen);
276 	if (peer->input.fd == -1) {
277 		syslog(LOG_WARNING, "%s: accept failed: %m", p->name);
278 		free(peer);
279 		return;
280 	}
281 
282 	if ((peer->input.id = fd_select(peer->input.fd, lsock_input,
283 	    peer, NULL)) == NULL) {
284 		close(peer->input.fd);
285 		free(peer);
286 		return;
287 	}
288 
289 	LIST_INSERT_HEAD(&p->peers, peer, link);
290 }
291 
292 /*
293  * Create a local socket
294  */
295 static int
296 lsock_init_port(struct tport *tp)
297 {
298 	struct lsock_port *p = (struct lsock_port *)tp;
299 	struct sockaddr_un sa;
300 
301 	if (p->type == LOCP_STREAM_PRIV || p->type == LOCP_STREAM_UNPRIV) {
302 		if ((p->str_sock = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0) {
303 			syslog(LOG_ERR, "creating local socket: %m");
304 			return (SNMP_ERR_RES_UNAVAIL);
305 		}
306 
307 		strcpy(sa.sun_path, p->name);
308 		sa.sun_family = AF_LOCAL;
309 		sa.sun_len = strlen(p->name) +
310 		    offsetof(struct sockaddr_un, sun_path);
311 
312 		(void)remove(p->name);
313 
314 		if (bind(p->str_sock, (struct sockaddr *)&sa, sizeof(sa))) {
315 			if (errno == EADDRNOTAVAIL) {
316 				close(p->str_sock);
317 				p->str_sock = -1;
318 				return (SNMP_ERR_INCONS_NAME);
319 			}
320 			syslog(LOG_ERR, "bind: %s %m", p->name);
321 			close(p->str_sock);
322 			p->str_sock = -1;
323 			return (SNMP_ERR_GENERR);
324 		}
325 		if (chmod(p->name, 0666) == -1)
326 			syslog(LOG_WARNING, "chmod(%s,0666): %m", p->name);
327 
328 		if (listen(p->str_sock, 10) == -1) {
329 			syslog(LOG_ERR, "listen: %s %m", p->name);
330 			(void)remove(p->name);
331 			close(p->str_sock);
332 			p->str_sock = -1;
333 			return (SNMP_ERR_GENERR);
334 		}
335 
336 		p->str_id = fd_select(p->str_sock, lsock_listen_input, p, NULL);
337 		if (p->str_id == NULL) {
338 			(void)remove(p->name);
339 			close(p->str_sock);
340 			p->str_sock = -1;
341 			return (SNMP_ERR_GENERR);
342 		}
343 	} else {
344 		struct lsock_peer *peer;
345 
346 		peer = LIST_FIRST(&p->peers);
347 
348 		if ((peer->input.fd = socket(PF_LOCAL, SOCK_DGRAM, 0)) < 0) {
349 			syslog(LOG_ERR, "creating local socket: %m");
350 			return (SNMP_ERR_RES_UNAVAIL);
351 		}
352 
353 		strcpy(sa.sun_path, p->name);
354 		sa.sun_family = AF_LOCAL;
355 		sa.sun_len = strlen(p->name) +
356 		    offsetof(struct sockaddr_un, sun_path);
357 
358 		(void)remove(p->name);
359 
360 		if (bind(peer->input.fd, (struct sockaddr *)&sa, sizeof(sa))) {
361 			if (errno == EADDRNOTAVAIL) {
362 				close(peer->input.fd);
363 				peer->input.fd = -1;
364 				return (SNMP_ERR_INCONS_NAME);
365 			}
366 			syslog(LOG_ERR, "bind: %s %m", p->name);
367 			close(peer->input.fd);
368 			peer->input.fd = -1;
369 			return (SNMP_ERR_GENERR);
370 		}
371 		if (chmod(p->name, 0666) == -1)
372 			syslog(LOG_WARNING, "chmod(%s,0666): %m", p->name);
373 
374 		peer->input.id = fd_select(peer->input.fd, lsock_input,
375 		    peer, NULL);
376 		if (peer->input.id == NULL) {
377 			(void)remove(p->name);
378 			close(peer->input.fd);
379 			peer->input.fd = -1;
380 			return (SNMP_ERR_GENERR);
381 		}
382 	}
383 	return (SNMP_ERR_NOERROR);
384 }
385 
386 /*
387  * Send something
388  */
389 static ssize_t
390 lsock_send(struct tport *tp, const u_char *buf, size_t len,
391     const struct sockaddr *addr, size_t addrlen)
392 {
393 	struct lsock_port *p = (struct lsock_port *)tp;
394 	struct lsock_peer *peer;
395 
396 	if (p->type == LOCP_DGRAM_PRIV || p->type == LOCP_DGRAM_UNPRIV) {
397 		peer = LIST_FIRST(&p->peers);
398 
399 	} else {
400 		/* search for the peer */
401 		LIST_FOREACH(peer, &p->peers, link)
402 			if (peer->input.peerlen == addrlen &&
403 			    memcmp(peer->input.peer, addr, addrlen) == 0)
404 				break;
405 		if (peer == NULL) {
406 			errno = ENOTCONN;
407 			return (-1);
408 		}
409 	}
410 
411 	return (sendto(peer->input.fd, buf, len, 0, addr, addrlen));
412 }
413 
414 /*
415  * Dependency to create a lsock port
416  */
417 struct lsock_dep {
418 	struct snmp_dependency dep;
419 
420 	/* index (path name) */
421 	u_char *path;
422 	size_t pathlen;
423 
424 	/* the port */
425 	struct lsock_port *port;
426 
427 	/* which of the fields are set */
428 	u_int set;
429 
430 	/* type of the port */
431 	int type;
432 
433 	/* status */
434 	int status;
435 };
436 #define	LD_TYPE		0x01
437 #define	LD_STATUS	0x02
438 #define	LD_CREATE	0x04	/* rollback create */
439 #define	LD_DELETE	0x08	/* rollback delete */
440 
441 /*
442  * dependency handler for lsock ports
443  */
444 static int
445 lsock_func(struct snmp_context *ctx, struct snmp_dependency *dep,
446     enum snmp_depop op)
447 {
448 	struct lsock_dep *ld = (struct lsock_dep *)(void *)dep;
449 	int err = SNMP_ERR_NOERROR;
450 
451 	switch (op) {
452 
453 	  case SNMP_DEPOP_COMMIT:
454 		if (!(ld->set & LD_STATUS))
455 			err = SNMP_ERR_BADVALUE;
456 		else if (ld->port == NULL) {
457 			if (!ld->status)
458 				err = SNMP_ERR_BADVALUE;
459 
460 			else {
461 				/* create */
462 				err = lsock_open_port(ld->path, ld->pathlen,
463 				    &ld->port, ld->type);
464 				if (err == SNMP_ERR_NOERROR)
465 					ld->set |= LD_CREATE;
466 			}
467 		} else if (!ld->status) {
468 			/* delete - hard to roll back so defer to finalizer */
469 			ld->set |= LD_DELETE;
470 		} else
471 			/* modify - read-only */
472 			err = SNMP_ERR_READONLY;
473 
474 		return (err);
475 
476 	  case SNMP_DEPOP_ROLLBACK:
477 		if (ld->set & LD_CREATE) {
478 			/* was create */
479 			lsock_close_port(&ld->port->tport);
480 		}
481 		return (SNMP_ERR_NOERROR);
482 
483 	  case SNMP_DEPOP_FINISH:
484 		if ((ld->set & LD_DELETE) && ctx->code == SNMP_RET_OK)
485 			lsock_close_port(&ld->port->tport);
486 		free(ld->path);
487 		return (SNMP_ERR_NOERROR);
488 	}
489 	abort();
490 }
491 
492 /*
493  * Local port table
494  */
495 int
496 op_lsock_port(struct snmp_context *ctx, struct snmp_value *value,
497     u_int sub, u_int iidx, enum snmp_op op)
498 {
499 	asn_subid_t which = value->var.subs[sub-1];
500 	struct lsock_port *p;
501 	u_char *name;
502 	size_t namelen;
503 	struct lsock_dep *ld;
504 	struct asn_oid didx;
505 
506 	switch (op) {
507 
508 	  case SNMP_OP_GETNEXT:
509 		if ((p = (struct lsock_port *)trans_next_port(my_trans,
510 		    &value->var, sub)) == NULL)
511 			return (SNMP_ERR_NOSUCHNAME);
512 		index_append(&value->var, sub, &p->tport.index);
513 		break;
514 
515 	  case SNMP_OP_GET:
516 		if ((p = (struct lsock_port *)trans_find_port(my_trans,
517 		    &value->var, sub)) == NULL)
518 			return (SNMP_ERR_NOSUCHNAME);
519 		break;
520 
521 	  case SNMP_OP_SET:
522 		p = (struct lsock_port *)trans_find_port(my_trans,
523 		    &value->var, sub);
524 
525 		if (index_decode(&value->var, sub, iidx, &name, &namelen))
526 			return (SNMP_ERR_NO_CREATION);
527 
528 		asn_slice_oid(&didx, &value->var, sub, value->var.len);
529 		if ((ld = (struct lsock_dep *)(void *)snmp_dep_lookup(ctx,
530 		    &oid_begemotSnmpdLocalPortTable, &didx, sizeof(*ld),
531 		    lsock_func)) == NULL) {
532 			free(name);
533 			return (SNMP_ERR_GENERR);
534 		}
535 
536 		if (ld->path == NULL) {
537 			ld->path = name;
538 			ld->pathlen = namelen;
539 		} else {
540 			free(name);
541 		}
542 		ld->port = p;
543 
544 		switch (which) {
545 
546 		  case LEAF_begemotSnmpdLocalPortStatus:
547 			if (ld->set & LD_STATUS)
548 				return (SNMP_ERR_INCONS_VALUE);
549 			if (!TRUTH_OK(value->v.integer))
550 				return (SNMP_ERR_WRONG_VALUE);
551 
552 			ld->status = TRUTH_GET(value->v.integer);
553 			ld->set |= LD_STATUS;
554 			break;
555 
556 		  case LEAF_begemotSnmpdLocalPortType:
557 			if (ld->set & LD_TYPE)
558 				return (SNMP_ERR_INCONS_VALUE);
559 			if (value->v.integer < 1 || value->v.integer > 4)
560 				return (SNMP_ERR_WRONG_VALUE);
561 
562 			ld->type = value->v.integer;
563 			ld->set |= LD_TYPE;
564 			break;
565 		}
566 		return (SNMP_ERR_NOERROR);
567 
568 	  case SNMP_OP_ROLLBACK:
569 	  case SNMP_OP_COMMIT:
570 		return (SNMP_ERR_NOERROR);
571 
572 	  default:
573 		abort();
574 	}
575 
576 	/*
577 	 * Come here to fetch the value
578 	 */
579 	switch (which) {
580 
581 	  case LEAF_begemotSnmpdLocalPortStatus:
582 		value->v.integer = 1;
583 		break;
584 
585 	  case LEAF_begemotSnmpdLocalPortType:
586 		value->v.integer = p->type;
587 		break;
588 
589 	  default:
590 		abort();
591 	}
592 
593 	return (SNMP_ERR_NOERROR);
594 }
595