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