1 /*
2  * Copyright (c) 2022 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/queue.h>
18 #include <sys/socket.h>
19 #include <sys/un.h>
20 
21 #include <err.h>
22 #include <event.h>
23 #include <imsg.h>
24 #include <limits.h>
25 #include <locale.h>
26 #include <sha1.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <getopt.h>
31 #include <unistd.h>
32 
33 #include "got_error.h"
34 #include "got_version.h"
35 
36 #include "got_lib_gitproto.h"
37 
38 #include "gotd.h"
39 
40 #ifndef nitems
41 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
42 #endif
43 
44 #define GOTCTL_CMD_INFO "info"
45 #define GOTCTL_CMD_STOP "stop"
46 
47 struct gotctl_cmd {
48 	const char	*cmd_name;
49 	const struct got_error *(*cmd_main)(int, char *[], int);
50 	void		(*cmd_usage)(void);
51 };
52 
53 __dead static void	usage(int, int);
54 
55 __dead static void	usage_info(void);
56 __dead static void	usage_stop(void);
57 
58 static const struct got_error*		cmd_info(int, char *[], int);
59 static const struct got_error*		cmd_stop(int, char *[], int);
60 
61 static const struct gotctl_cmd gotctl_commands[] = {
62 	{ "info",	cmd_info,	usage_info },
63 	{ "stop",	cmd_stop,	usage_stop },
64 };
65 
66 __dead static void
67 usage_info(void)
68 {
69 	fprintf(stderr, "usage: %s info\n", getprogname());
70 	exit(1);
71 }
72 
73 static const struct got_error *
74 show_info(struct imsg *imsg)
75 {
76 	struct gotd_imsg_info info;
77 	size_t datalen;
78 
79 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
80 	if (datalen != sizeof(info))
81 		return got_error(GOT_ERR_PRIVSEP_LEN);
82 	memcpy(&info, imsg->data, sizeof(info));
83 
84 	printf("gotd PID: %d\n", info.pid);
85 	printf("verbosity: %d\n", info.verbosity);
86 	printf("number of repositories: %d\n", info.nrepos);
87 	printf("number of connected clients: %d\n", info.nclients);
88 	return NULL;
89 }
90 
91 static const struct got_error *
92 show_repo_info(struct imsg *imsg)
93 {
94 	struct gotd_imsg_info_repo info;
95 	size_t datalen;
96 
97 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
98 	if (datalen != sizeof(info))
99 		return got_error(GOT_ERR_PRIVSEP_LEN);
100 	memcpy(&info, imsg->data, sizeof(info));
101 
102 	printf("repository \"%s\", path %s\n", info.repo_name, info.repo_path);
103 	return NULL;
104 }
105 
106 static const struct got_error *
107 show_client_info(struct imsg *imsg)
108 {
109 	struct gotd_imsg_info_client info;
110 	size_t datalen;
111 
112 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
113 	if (datalen != sizeof(info))
114 		return got_error(GOT_ERR_PRIVSEP_LEN);
115 	memcpy(&info, imsg->data, sizeof(info));
116 
117 	printf("client UID %d, GID %d, ", info.euid, info.egid);
118 	if (info.session_child_pid)
119 		printf("session PID %ld, ", (long)info.session_child_pid);
120 	if (info.repo_child_pid)
121 		printf("repo PID %ld, ", (long)info.repo_child_pid);
122 	if (info.is_writing)
123 		printf("writing to %s\n", info.repo_name);
124 	else
125 		printf("reading from %s\n", info.repo_name);
126 
127 	return NULL;
128 }
129 
130 static const struct got_error *
131 cmd_info(int argc, char *argv[], int gotd_sock)
132 {
133 	const struct got_error *err;
134 	struct imsgbuf ibuf;
135 	struct imsg imsg;
136 
137 	imsg_init(&ibuf, gotd_sock);
138 
139 	if (imsg_compose(&ibuf, GOTD_IMSG_INFO, 0, 0, -1, NULL, 0) == -1)
140 		return got_error_from_errno("imsg_compose INFO");
141 
142 	err = gotd_imsg_flush(&ibuf);
143 	while (err == NULL) {
144 		err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
145 		if (err) {
146 			if (err->code == GOT_ERR_EOF)
147 				err = NULL;
148 			break;
149 		}
150 		
151 		switch (imsg.hdr.type) {
152 		case GOTD_IMSG_ERROR:
153 			err = gotd_imsg_recv_error(NULL, &imsg);
154 			break;
155 		case GOTD_IMSG_INFO:
156 			err = show_info(&imsg);
157 			break;
158 		case GOTD_IMSG_INFO_REPO:
159 			err = show_repo_info(&imsg);
160 			break;
161 		case GOTD_IMSG_INFO_CLIENT:
162 			err = show_client_info(&imsg);
163 			break;
164 		default:
165 			err = got_error(GOT_ERR_PRIVSEP_MSG);
166 			break;
167 		}
168 
169 		imsg_free(&imsg);
170 	}
171 
172 	imsg_clear(&ibuf);
173 	return err;
174 }
175 
176 __dead static void
177 usage_stop(void)
178 {
179 	fprintf(stderr, "usage: %s stop\n", getprogname());
180 	exit(1);
181 }
182 
183 static const struct got_error *
184 cmd_stop(int argc, char *argv[], int gotd_sock)
185 {
186 	const struct got_error *err;
187 	struct imsgbuf ibuf;
188 	struct imsg imsg;
189 
190 	imsg_init(&ibuf, gotd_sock);
191 
192 	if (imsg_compose(&ibuf, GOTD_IMSG_STOP, 0, 0, -1, NULL, 0) == -1)
193 		return got_error_from_errno("imsg_compose STOP");
194 
195 	err = gotd_imsg_flush(&ibuf);
196 	while (err == NULL) {
197 		err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
198 		if (err) {
199 			if (err->code == GOT_ERR_EOF)
200 				err = NULL;
201 			break;
202 		}
203 		
204 		switch (imsg.hdr.type) {
205 		case GOTD_IMSG_ERROR:
206 			err = gotd_imsg_recv_error(NULL, &imsg);
207 			break;
208 		default:
209 			err = got_error(GOT_ERR_PRIVSEP_MSG);
210 			break;
211 		}
212 
213 		imsg_free(&imsg);
214 	}
215 
216 	imsg_clear(&ibuf);
217 	return err;
218 }
219 
220 static void
221 list_commands(FILE *fp)
222 {
223 	size_t i;
224 
225 	fprintf(fp, "commands:");
226 	for (i = 0; i < nitems(gotctl_commands); i++) {
227 		const struct gotctl_cmd *cmd = &gotctl_commands[i];
228 		fprintf(fp, " %s", cmd->cmd_name);
229 	}
230 	fputc('\n', fp);
231 }
232 
233 __dead static void
234 usage(int hflag, int status)
235 {
236 	FILE *fp = (status == 0) ? stdout : stderr;
237 
238 	fprintf(fp, "usage: %s [-hV] [-f path] command [arg ...]\n",
239 	    getprogname());
240 	if (hflag)
241 		list_commands(fp);
242 	exit(status);
243 }
244 
245 static const struct got_error *
246 apply_unveil(const char *unix_socket_path)
247 {
248 #ifdef PROFILE
249 	if (unveil("gmon.out", "rwc") != 0)
250 		return got_error_from_errno2("unveil", "gmon.out");
251 #endif
252 	if (unveil(unix_socket_path, "w") != 0)
253 		return got_error_from_errno2("unveil", unix_socket_path);
254 
255 	if (unveil(NULL, NULL) != 0)
256 		return got_error_from_errno("unveil");
257 
258 	return NULL;
259 }
260 
261 static int
262 connect_gotd(const char *socket_path)
263 {
264 	const struct got_error *error = NULL;
265 	int gotd_sock = -1;
266 	struct sockaddr_un sun;
267 
268 	error = apply_unveil(socket_path);
269 	if (error)
270 		errx(1, "%s", error->msg);
271 
272 #ifndef PROFILE
273 	if (pledge("stdio unix", NULL) == -1)
274 		err(1, "pledge");
275 #endif
276 	if ((gotd_sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
277 		err(1, "socket");
278 
279 	memset(&sun, 0, sizeof(sun));
280 	sun.sun_family = AF_UNIX;
281 	if (strlcpy(sun.sun_path, socket_path, sizeof(sun.sun_path)) >=
282 	    sizeof(sun.sun_path))
283 		errx(1, "gotd socket path too long");
284 	if (connect(gotd_sock, (struct sockaddr *)&sun, sizeof(sun)) == -1)
285 		err(1, "connect: %s", socket_path);
286 
287 #ifndef PROFILE
288 	if (pledge("stdio", NULL) == -1)
289 		err(1, "pledge");
290 #endif
291 
292 	return gotd_sock;
293 }
294 
295 int
296 main(int argc, char *argv[])
297 {
298 	const struct gotctl_cmd *cmd;
299 	int gotd_sock = -1, i;
300 	int ch;
301 	int hflag = 0, Vflag = 0;
302 	static const struct option longopts[] = {
303 	    { "version", no_argument, NULL, 'V' },
304 	    { NULL, 0, NULL, 0 }
305 	};
306 	const char *socket_path = GOTD_UNIX_SOCKET;
307 
308 	setlocale(LC_CTYPE, "");
309 
310 #ifndef PROFILE
311 	if (pledge("stdio unix unveil", NULL) == -1)
312 		err(1, "pledge");
313 #endif
314 
315 	while ((ch = getopt_long(argc, argv, "+hf:V", longopts, NULL)) != -1) {
316 		switch (ch) {
317 		case 'h':
318 			hflag = 1;
319 			break;
320 		case 'f':
321 			socket_path = optarg;
322 			break;
323 		case 'V':
324 			Vflag = 1;
325 			break;
326 		default:
327 			usage(hflag, 1);
328 			/* NOTREACHED */
329 		}
330 	}
331 
332 	argc -= optind;
333 	argv += optind;
334 	optind = 1;
335 	optreset = 1;
336 
337 	if (Vflag) {
338 		got_version_print_str();
339 		return 0;
340 	}
341 
342 	if (argc <= 0)
343 		usage(hflag, hflag ? 0 : 1);
344 
345 	for (i = 0; i < nitems(gotctl_commands); i++) {
346 		const struct got_error *error;
347 
348 		cmd = &gotctl_commands[i];
349 
350 		if (strncmp(cmd->cmd_name, argv[0], strlen(argv[0])) != 0)
351 			continue;
352 
353 		if (hflag)
354 			cmd->cmd_usage();
355 
356 		gotd_sock = connect_gotd(socket_path);
357 		if (gotd_sock == -1)
358 			return 1;
359 		error = cmd->cmd_main(argc, argv, gotd_sock);
360 		close(gotd_sock);
361 		if (error) {
362 			fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
363 			return 1;
364 		}
365 
366 		return 0;
367 	}
368 
369 	fprintf(stderr, "%s: unknown command '%s'\n", getprogname(), argv[0]);
370 	list_commands(stderr);
371 	return 1;
372 }