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/types.h>
19 #include <sys/uio.h>
20 
21 #include <errno.h>
22 #include <event.h>
23 #include <imsg.h>
24 #include <limits.h>
25 #include <poll.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <unistd.h>
29 
30 #include "got_error.h"
31 
32 #include "got_lib_poll.h"
33 
34 #include "gotd.h"
35 
36 const struct got_error *
37 gotd_imsg_recv_error(uint32_t *client_id, struct imsg *imsg)
38 {
39 	struct gotd_imsg_error ierr;
40 	size_t datalen;
41 
42 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
43 	if (datalen != sizeof(ierr))
44 		return got_error(GOT_ERR_PRIVSEP_LEN);
45 	memcpy(&ierr, imsg->data, sizeof(ierr));
46 
47 	if (client_id)
48 		*client_id = ierr.client_id;
49 
50 	if (ierr.code == GOT_ERR_ERRNO)
51 		errno = ierr.errno_code;
52 
53 	return got_error_msg(ierr.code, ierr.msg);
54 }
55 
56 const struct got_error *
57 gotd_imsg_flush(struct imsgbuf *ibuf)
58 {
59 	const struct got_error *err = NULL;
60 
61 	while (ibuf->w.queued > 0) {
62 		err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
63 		if (err)
64 			break;
65 
66 		if (imsg_flush(ibuf) == -1) {
67 			if (errno != EAGAIN) {
68 				imsg_clear(ibuf);
69 				err = got_error_from_errno("imsg_flush");
70 				break;
71 			}
72 		}
73 	}
74 
75 	return err;
76 }
77 
78 const struct got_error *
79 gotd_imsg_recv(struct imsg *imsg, struct imsgbuf *ibuf, size_t min_datalen)
80 {
81 	ssize_t n;
82 
83 	n = imsg_get(ibuf, imsg);
84 	if (n == -1)
85 		return got_error_from_errno("imsg_get");
86 
87 	if (n == 0) {
88 		n = imsg_read(ibuf);
89 		if (n == -1) {
90 			if (errno == EAGAIN)
91 				return got_error(GOT_ERR_PRIVSEP_READ);
92 			return got_error_from_errno("imsg_read");
93 		}
94 		if (n == 0)
95 			return got_error(GOT_ERR_EOF);
96 		n = imsg_get(ibuf, imsg);
97 		if (n == -1)
98 			return got_error_from_errno("imsg_get");
99 	}
100 
101 	if (imsg->hdr.len < IMSG_HEADER_SIZE + min_datalen)
102 		return got_error(GOT_ERR_PRIVSEP_LEN);
103 
104 	return NULL;
105 }
106 
107 const struct got_error *
108 gotd_imsg_poll_recv(struct imsg *imsg, struct imsgbuf *ibuf, size_t min_datalen)
109 {
110 	const struct got_error *err = NULL;
111 
112 	for (;;) {
113 		err = gotd_imsg_recv(imsg, ibuf, min_datalen);
114 		if (err == NULL || err->code != GOT_ERR_PRIVSEP_READ)
115 			return err;
116 
117 		err = got_poll_fd(ibuf->fd, POLLIN, INFTIM);
118 		if (err)
119 			break;
120 	}
121 
122 	return err;
123 }
124 
125 int
126 gotd_imsg_send_error(struct imsgbuf *ibuf, uint32_t peerid,
127     uint32_t client_id, const struct got_error *err)
128 {
129 	const struct got_error *flush_err;
130 	struct gotd_imsg_error ierr;
131 	int ret;
132 
133 	ierr.code = err->code;
134 	if (err->code == GOT_ERR_ERRNO)
135 		ierr.errno_code = errno;
136 	else
137 		ierr.errno_code = 0;
138 	ierr.client_id = client_id;
139 	strlcpy(ierr.msg, err->msg, sizeof(ierr.msg));
140 
141 	ret = imsg_compose(ibuf, GOTD_IMSG_ERROR, peerid, getpid(), -1,
142 	    &ierr, sizeof(ierr));
143 	if (ret == -1)
144 		return -1;
145 
146 	flush_err = gotd_imsg_flush(ibuf);
147 	if (flush_err)
148 		return -1;
149 
150 	return 0;
151 }
152 
153 int
154 gotd_imsg_send_error_event(struct gotd_imsgev *iev, uint32_t peerid,
155     uint32_t client_id, const struct got_error *err)
156 {
157 	struct gotd_imsg_error ierr;
158 	int ret;
159 
160 	ierr.code = err->code;
161 	if (err->code == GOT_ERR_ERRNO)
162 		ierr.errno_code = errno;
163 	else
164 		ierr.errno_code = 0;
165 	ierr.client_id = client_id;
166 	strlcpy(ierr.msg, err->msg, sizeof(ierr.msg));
167 
168 	ret = gotd_imsg_compose_event(iev, GOTD_IMSG_ERROR, peerid, -1,
169 	    &ierr, sizeof(ierr));
170 	if (ret == -1)
171 		return -1;
172 
173 	return 0;
174 }
175 
176 void
177 gotd_imsg_event_add(struct gotd_imsgev *iev)
178 {
179 	iev->events = EV_READ;
180 	if (iev->ibuf.w.queued)
181 		iev->events |= EV_WRITE;
182 
183 	event_del(&iev->ev);
184 	event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
185 	event_add(&iev->ev, NULL);
186 }
187 
188 int
189 gotd_imsg_compose_event(struct gotd_imsgev *iev, uint16_t type, uint32_t peerid,
190     int fd, void *data, uint16_t datalen)
191 {
192 	int ret;
193 
194 	ret = imsg_compose(&iev->ibuf, type, peerid, getpid(), fd,
195 	    data, datalen);
196 	if (ret != -1)
197 		gotd_imsg_event_add(iev);
198 
199 	return ret;
200 }
201 
202 int
203 gotd_imsg_forward(struct gotd_imsgev *iev, struct imsg *imsg, int fd)
204 {
205 	return gotd_imsg_compose_event(iev, imsg->hdr.type, imsg->hdr.peerid,
206 	    fd, imsg->data, imsg->hdr.len - IMSG_HEADER_SIZE);
207 }