GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.sbin/relayctl/relayctl.c Lines: 0 253 0.0 %
Date: 2017-11-13 Branches: 0 160 0.0 %

Line Branch Exec Source
1
/*	$OpenBSD: relayctl.c,v 1.57 2016/09/03 14:44:21 reyk Exp $	*/
2
3
/*
4
 * Copyright (c) 2007 - 2013 Reyk Floeter <reyk@openbsd.org>
5
 * Copyright (c) 2006 Pierre-Yves Ritschard <pyr@openbsd.org>
6
 * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
7
 * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
8
 * Copyright (c) 2003 Henning Brauer <henning@openbsd.org>
9
 *
10
 * Permission to use, copy, modify, and distribute this software for any
11
 * purpose with or without fee is hereby granted, provided that the above
12
 * copyright notice and this permission notice appear in all copies.
13
 *
14
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
17
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
 */
22
23
#include <sys/types.h>
24
#include <sys/socket.h>
25
#include <sys/time.h>
26
#include <sys/queue.h>
27
#include <sys/un.h>
28
29
#include <arpa/inet.h>
30
31
#include <stdio.h>
32
#include <stdlib.h>
33
#include <err.h>
34
#include <errno.h>
35
#include <limits.h>
36
#include <string.h>
37
#include <unistd.h>
38
#include <time.h>
39
#include <imsg.h>
40
41
#include "relayd.h"
42
#include "parser.h"
43
44
__dead void	 usage(void);
45
int		 show_summary_msg(struct imsg *, int);
46
int		 show_session_msg(struct imsg *);
47
int		 show_command_output(struct imsg *);
48
char		*print_rdr_status(int);
49
char		*print_host_status(int, int);
50
char		*print_table_status(int, int);
51
char		*print_relay_status(int);
52
void		 print_statistics(struct ctl_stats[PROC_MAX_INSTANCES + 1]);
53
54
struct imsgname {
55
	int type;
56
	char *name;
57
	void (*func)(struct imsg *);
58
};
59
60
struct imsgname *monitor_lookup(u_int8_t);
61
void		 monitor_host_status(struct imsg *);
62
void		 monitor_id(struct imsg *);
63
int		 monitor(struct imsg *);
64
65
struct imsgname imsgs[] = {
66
	{ IMSG_HOST_STATUS,		"host_status",	monitor_host_status },
67
	{ IMSG_CTL_RDR_DISABLE,		"ctl_rdr_disable",	monitor_id },
68
	{ IMSG_CTL_RDR_ENABLE,		"ctl_rdr_enable",	monitor_id },
69
	{ IMSG_CTL_TABLE_DISABLE,	"ctl_table_disable",	monitor_id },
70
	{ IMSG_CTL_TABLE_ENABLE,	"ctl_table_enable",	monitor_id },
71
	{ IMSG_CTL_HOST_DISABLE,	"ctl_host_disable",	monitor_id },
72
	{ IMSG_CTL_HOST_ENABLE,		"ctl_host_enable",	monitor_id },
73
	{ IMSG_CTL_TABLE_CHANGED,	"ctl_table_changed",	monitor_id },
74
	{ IMSG_CTL_PULL_RULESET,	"ctl_pull_ruleset",	monitor_id },
75
	{ IMSG_CTL_PUSH_RULESET,	"ctl_push_ruleset",	monitor_id },
76
	{ IMSG_SYNC,			"sync",			NULL },
77
	{ 0,				NULL,			NULL }
78
};
79
struct imsgname imsgunknown = {
80
	-1,				"<unknown>",		NULL
81
};
82
83
struct imsgbuf	*ibuf;
84
int error = 0;
85
86
__dead void
87
usage(void)
88
{
89
	extern char *__progname;
90
91
	fprintf(stderr, "usage: %s command [argument ...]\n", __progname);
92
	exit(1);
93
}
94
95
int
96
main(int argc, char *argv[])
97
{
98
	struct sockaddr_un	 sun;
99
	struct parse_result	*res;
100
	struct imsg		 imsg;
101
	int			 ctl_sock;
102
	int			 done = 0;
103
	int			 n, verbose = 0;
104
105
	/* parse options */
106
	if ((res = parse(argc - 1, argv + 1)) == NULL)
107
		exit(1);
108
109
	/* connect to relayd control socket */
110
	if ((ctl_sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
111
		err(1, "socket");
112
113
	bzero(&sun, sizeof(sun));
114
	sun.sun_family = AF_UNIX;
115
	(void)strlcpy(sun.sun_path, RELAYD_SOCKET, sizeof(sun.sun_path));
116
 reconnect:
117
	if (connect(ctl_sock, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
118
		/* Keep retrying if running in monitor mode */
119
		if (res->action == MONITOR &&
120
		    (errno == ENOENT || errno == ECONNREFUSED)) {
121
			usleep(100);
122
			goto reconnect;
123
		}
124
		err(1, "connect: %s", RELAYD_SOCKET);
125
	}
126
127
	if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
128
		err(1, "pledge");
129
130
	if ((ibuf = malloc(sizeof(struct imsgbuf))) == NULL)
131
		err(1, NULL);
132
	imsg_init(ibuf, ctl_sock);
133
	done = 0;
134
135
	/* process user request */
136
	switch (res->action) {
137
	case NONE:
138
		usage();
139
		/* not reached */
140
	case SHOW_SUM:
141
	case SHOW_HOSTS:
142
	case SHOW_RDRS:
143
	case SHOW_RELAYS:
144
	case SHOW_ROUTERS:
145
		imsg_compose(ibuf, IMSG_CTL_SHOW_SUM, 0, 0, -1, NULL, 0);
146
		printf("%-4s\t%-8s\t%-24s\t%-7s\tStatus\n",
147
		    "Id", "Type", "Name", "Avlblty");
148
		break;
149
	case SHOW_SESSIONS:
150
		imsg_compose(ibuf, IMSG_CTL_SESSION, 0, 0, -1, NULL, 0);
151
		break;
152
	case RDR_ENABLE:
153
		imsg_compose(ibuf, IMSG_CTL_RDR_ENABLE, 0, 0, -1,
154
		    &res->id, sizeof(res->id));
155
		break;
156
	case RDR_DISABLE:
157
		imsg_compose(ibuf, IMSG_CTL_RDR_DISABLE, 0, 0, -1,
158
		    &res->id, sizeof(res->id));
159
		break;
160
	case TABLE_ENABLE:
161
		imsg_compose(ibuf, IMSG_CTL_TABLE_ENABLE, 0, 0, -1,
162
		    &res->id, sizeof(res->id));
163
		break;
164
	case TABLE_DISABLE:
165
		imsg_compose(ibuf, IMSG_CTL_TABLE_DISABLE, 0, 0, -1,
166
		    &res->id, sizeof(res->id));
167
		break;
168
	case HOST_ENABLE:
169
		imsg_compose(ibuf, IMSG_CTL_HOST_ENABLE, 0, 0, -1,
170
		    &res->id, sizeof(res->id));
171
		break;
172
	case HOST_DISABLE:
173
		imsg_compose(ibuf, IMSG_CTL_HOST_DISABLE, 0, 0, -1,
174
		    &res->id, sizeof(res->id));
175
		break;
176
	case SHUTDOWN:
177
		imsg_compose(ibuf, IMSG_CTL_SHUTDOWN, 0, 0, -1, NULL, 0);
178
		break;
179
	case POLL:
180
		imsg_compose(ibuf, IMSG_CTL_POLL, 0, 0, -1, NULL, 0);
181
		break;
182
	case LOAD:
183
		imsg_compose(ibuf, IMSG_CTL_RELOAD, 0, 0, -1,
184
		    res->path, strlen(res->path));
185
		done = 1;
186
		break;
187
	case RELOAD:
188
		imsg_compose(ibuf, IMSG_CTL_RELOAD, 0, 0, -1, NULL, 0);
189
		done = 1;
190
		break;
191
	case MONITOR:
192
		imsg_compose(ibuf, IMSG_CTL_NOTIFY, 0, 0, -1, NULL, 0);
193
		break;
194
	case LOG_VERBOSE:
195
		verbose = 2;
196
		/* FALLTHROUGH */
197
	case LOG_BRIEF:
198
		imsg_compose(ibuf, IMSG_CTL_VERBOSE, 0, 0, -1,
199
		    &verbose, sizeof(verbose));
200
		printf("logging request sent.\n");
201
		done = 1;
202
		break;
203
	}
204
205
	while (ibuf->w.queued)
206
		if (msgbuf_write(&ibuf->w) <= 0 && errno != EAGAIN)
207
			err(1, "write error");
208
209
	while (!done) {
210
		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
211
			errx(1, "imsg_read error");
212
		if (n == 0)
213
			errx(1, "pipe closed");
214
215
		while (!done) {
216
			if ((n = imsg_get(ibuf, &imsg)) == -1)
217
				errx(1, "imsg_get error");
218
			if (n == 0)
219
				break;
220
			switch (res->action) {
221
			case SHOW_SUM:
222
			case SHOW_HOSTS:
223
			case SHOW_RDRS:
224
			case SHOW_RELAYS:
225
			case SHOW_ROUTERS:
226
				done = show_summary_msg(&imsg, res->action);
227
				break;
228
			case SHOW_SESSIONS:
229
				done = show_session_msg(&imsg);
230
				break;
231
			case RDR_DISABLE:
232
			case RDR_ENABLE:
233
			case TABLE_DISABLE:
234
			case TABLE_ENABLE:
235
			case HOST_DISABLE:
236
			case HOST_ENABLE:
237
			case POLL:
238
			case SHUTDOWN:
239
				done = show_command_output(&imsg);
240
				break;
241
			case NONE:
242
			case LOG_VERBOSE:
243
			case LOG_BRIEF:
244
			case RELOAD:
245
			case LOAD:
246
				break;
247
			case MONITOR:
248
				done = monitor(&imsg);
249
				break;
250
			}
251
			imsg_free(&imsg);
252
		}
253
	}
254
	close(ctl_sock);
255
	free(ibuf);
256
257
	return (error ? 1 : 0);
258
}
259
260
struct imsgname *
261
monitor_lookup(u_int8_t type)
262
{
263
	int i;
264
265
	for (i = 0; imsgs[i].name != NULL; i++)
266
		if (imsgs[i].type == type)
267
			return (&imsgs[i]);
268
	return (&imsgunknown);
269
}
270
271
void
272
monitor_host_status(struct imsg *imsg)
273
{
274
	struct ctl_status	 cs;
275
276
	memcpy(&cs, imsg->data, sizeof(cs));
277
	printf("\tid: %u\n", cs.id);
278
	printf("\tstate: ");
279
	switch (cs.up) {
280
	case HOST_UP:
281
		printf("up\n");
282
		break;
283
	case HOST_DOWN:
284
		printf("down\n");
285
		break;
286
	default:
287
		printf("unknown\n");
288
		break;
289
	}
290
}
291
292
void
293
monitor_id(struct imsg *imsg)
294
{
295
	struct ctl_id		 id;
296
297
	memcpy(&id, imsg->data, sizeof(id));
298
	printf("\tid: %u\n", id.id);
299
	if (strlen(id.name))
300
		printf("\tname: %s\n", id.name);
301
}
302
303
int
304
monitor(struct imsg *imsg)
305
{
306
	time_t			 now;
307
	int			 done = 0;
308
	struct imsgname		*imn;
309
310
	now = time(NULL);
311
312
	imn = monitor_lookup(imsg->hdr.type);
313
	printf("%s: imsg type %u len %u peerid %u pid %d\n", imn->name,
314
	    imsg->hdr.type, imsg->hdr.len, imsg->hdr.peerid, imsg->hdr.pid);
315
	printf("\ttimestamp: %lld, %s", (long long)now, ctime(&now));
316
	if (imn->type == -1)
317
		done = 1;
318
	if (imn->func != NULL)
319
		(*imn->func)(imsg);
320
321
	return (done);
322
}
323
324
int
325
show_summary_msg(struct imsg *imsg, int type)
326
{
327
	struct rdr		*rdr;
328
	struct table		*table;
329
	struct host		*host;
330
	struct relay		*rlay;
331
	struct router		*rt;
332
	struct netroute		*nr;
333
	struct ctl_stats	 stats[PROC_MAX_INSTANCES];
334
	char			 name[HOST_NAME_MAX+1];
335
336
	switch (imsg->hdr.type) {
337
	case IMSG_CTL_RDR:
338
		if (!(type == SHOW_SUM || type == SHOW_RDRS))
339
			break;
340
		rdr = imsg->data;
341
		printf("%-4u\t%-8s\t%-24s\t%-7s\t%s\n",
342
		    rdr->conf.id, "redirect", rdr->conf.name, "",
343
		    print_rdr_status(rdr->conf.flags));
344
		break;
345
	case IMSG_CTL_TABLE:
346
		if (!(type == SHOW_SUM || type == SHOW_HOSTS))
347
			break;
348
		table = imsg->data;
349
		printf("%-4u\t%-8s\t%-24s\t%-7s\t%s\n",
350
		    table->conf.id, "table", table->conf.name, "",
351
		    print_table_status(table->up, table->conf.flags));
352
		break;
353
	case IMSG_CTL_HOST:
354
		if (!(type == SHOW_SUM || type == SHOW_HOSTS))
355
			break;
356
		host = imsg->data;
357
		if (host->conf.parentid)
358
			snprintf(name, sizeof(name), "%s parent %u",
359
			    host->conf.name, host->conf.parentid);
360
		else
361
			strlcpy(name, host->conf.name, sizeof(name));
362
		printf("%-4u\t%-8s\t%-24s\t%-7s\t%s\n",
363
		    host->conf.id, "host", name,
364
		    print_availability(host->check_cnt, host->up_cnt),
365
		    print_host_status(host->up, host->flags));
366
		if (type == SHOW_HOSTS && host->check_cnt) {
367
			printf("\t%8s\ttotal: %lu/%lu checks",
368
			    "", host->up_cnt, host->check_cnt);
369
			if (host->retry_cnt)
370
				printf(", %d retries", host->retry_cnt);
371
			if (host->he && host->up == HOST_DOWN)
372
				printf(", error: %s", host_error(host->he));
373
			printf("\n");
374
		}
375
		break;
376
	case IMSG_CTL_RELAY:
377
		if (!(type == SHOW_SUM || type == SHOW_RELAYS))
378
			break;
379
		rlay = imsg->data;
380
		printf("%-4u\t%-8s\t%-24s\t%-7s\t%s\n",
381
		    rlay->rl_conf.id, "relay", rlay->rl_conf.name, "",
382
		    print_relay_status(rlay->rl_conf.flags));
383
		break;
384
	case IMSG_CTL_RDR_STATS:
385
		if (type != SHOW_RDRS)
386
			break;
387
		bcopy(imsg->data, &stats[0], sizeof(stats[0]));
388
		stats[1].id = EMPTY_ID;
389
		print_statistics(stats);
390
		break;
391
	case IMSG_CTL_RELAY_STATS:
392
		if (type != SHOW_RELAYS)
393
			break;
394
		bcopy(imsg->data, &stats, sizeof(stats));
395
		print_statistics(stats);
396
		break;
397
	case IMSG_CTL_ROUTER:
398
		if (!(type == SHOW_SUM || type == SHOW_ROUTERS))
399
			break;
400
		rt = imsg->data;
401
		printf("%-4u\t%-8s\t%-24s\t%-7s\t%s\n",
402
		    rt->rt_conf.id, "router", rt->rt_conf.name, "",
403
		    print_relay_status(rt->rt_conf.flags));
404
		if (type != SHOW_ROUTERS)
405
			break;
406
		if (rt->rt_conf.rtable)
407
			printf("\t%8s\trtable: %d\n", "", rt->rt_conf.rtable);
408
		if (strlen(rt->rt_conf.label))
409
			printf("\t%8s\trtlabel: %s\n", "", rt->rt_conf.label);
410
		break;
411
	case IMSG_CTL_NETROUTE:
412
		if (type != SHOW_ROUTERS)
413
			break;
414
		nr = imsg->data;
415
		(void)print_host(&nr->nr_conf.ss, name, sizeof(name));
416
		printf("\t%8s\troute: %s/%d\n",
417
		    "", name, nr->nr_conf.prefixlen);
418
		break;
419
	case IMSG_CTL_END:
420
		return (1);
421
	default:
422
		errx(1, "wrong message in summary: %u", imsg->hdr.type);
423
		break;
424
	}
425
	return (0);
426
}
427
428
int
429
show_session_msg(struct imsg *imsg)
430
{
431
	struct rsession		*con;
432
	char			 a[128], b[128];
433
	struct timeval		 tv_now;
434
435
	switch (imsg->hdr.type) {
436
	case IMSG_CTL_SESSION:
437
		con = imsg->data;
438
439
		(void)print_host(&con->se_in.ss, a, sizeof(a));
440
		(void)print_host(&con->se_out.ss, b, sizeof(b));
441
		printf("session %u:%u %s:%u -> %s:%u\t%s\n",
442
		    imsg->hdr.peerid, con->se_id,
443
		    a, ntohs(con->se_in.port), b, ntohs(con->se_out.port),
444
		    con->se_done ? "DONE" : "RUNNING");
445
446
		getmonotime(&tv_now);
447
		print_time(&tv_now, &con->se_tv_start, a, sizeof(a));
448
		print_time(&tv_now, &con->se_tv_last, b, sizeof(b));
449
		printf("\tage %s, idle %s, relay %u, pid %u",
450
		    a, b, con->se_relayid, con->se_pid);
451
		/* XXX grab tagname instead of tag id */
452
		if (con->se_tag)
453
			printf(", tag (id) %u", con->se_tag);
454
		printf("\n");
455
		break;
456
	case IMSG_CTL_END:
457
		return (1);
458
	default:
459
		errx(1, "wrong message in session: %u", imsg->hdr.type);
460
		break;
461
	}
462
	return (0);
463
}
464
465
int
466
show_command_output(struct imsg *imsg)
467
{
468
	switch (imsg->hdr.type) {
469
	case IMSG_CTL_OK:
470
		printf("command succeeded\n");
471
		break;
472
	case IMSG_CTL_FAIL:
473
		printf("command failed\n");
474
		error++;
475
		break;
476
	default:
477
		errx(1, "wrong message in summary: %u", imsg->hdr.type);
478
	}
479
	return (1);
480
}
481
482
char *
483
print_rdr_status(int flags)
484
{
485
	if (flags & F_DISABLE) {
486
		return ("disabled");
487
	} else if (flags & F_DOWN) {
488
		return ("down");
489
	} else if (flags & F_BACKUP) {
490
		return ("active (using backup table)");
491
	} else
492
		return ("active");
493
}
494
495
char *
496
print_table_status(int up, int fl)
497
{
498
	static char buf[1024];
499
500
	bzero(buf, sizeof(buf));
501
502
	if (fl & F_DISABLE) {
503
		snprintf(buf, sizeof(buf) - 1, "disabled");
504
	} else if (!up) {
505
		snprintf(buf, sizeof(buf) - 1, "empty");
506
	} else
507
		snprintf(buf, sizeof(buf) - 1, "active (%d hosts)", up);
508
	return (buf);
509
}
510
511
char *
512
print_host_status(int status, int fl)
513
{
514
	if (fl & F_DISABLE)
515
		return ("disabled");
516
517
	switch (status) {
518
	case HOST_DOWN:
519
		return ("down");
520
	case HOST_UNKNOWN:
521
		return ("unknown");
522
	case HOST_UP:
523
		return ("up");
524
	default:
525
		errx(1, "invalid status: %d", status);
526
	}
527
}
528
529
char *
530
print_relay_status(int flags)
531
{
532
	if (flags & F_DISABLE) {
533
		return ("disabled");
534
	} else
535
		return ("active");
536
}
537
538
void
539
print_statistics(struct ctl_stats stats[PROC_MAX_INSTANCES + 1])
540
{
541
	struct ctl_stats	 crs;
542
	int			 i;
543
544
	bzero(&crs, sizeof(crs));
545
	crs.interval = stats[0].interval;
546
	for (i = 0; stats[i].id != EMPTY_ID; i++) {
547
		crs.cnt += stats[i].cnt;
548
		crs.last += stats[i].last;
549
		crs.avg += stats[i].avg;
550
		crs.last_hour += stats[i].last_hour;
551
		crs.avg_hour += stats[i].avg_hour;
552
		crs.last_day += stats[i].last_day;
553
		crs.avg_day += stats[i].avg_day;
554
	}
555
	if (crs.cnt == 0)
556
		return;
557
	printf("\t%8s\ttotal: %llu sessions\n"
558
	    "\t%8s\tlast: %u/%llus %u/h %u/d sessions\n"
559
	    "\t%8s\taverage: %u/%llus %u/h %u/d sessions\n",
560
	    "", crs.cnt,
561
	    "", crs.last, crs.interval,
562
	    crs.last_hour, crs.last_day,
563
	    "", crs.avg, crs.interval,
564
	    crs.avg_hour, crs.avg_day);
565
}