Blame
Date:
Sun Mar 27 12:52:58 2022 UTC
Message:
prefer sizeof(x) instead of datalen
001
2021-01-16
op
/*
002
2021-01-16
op
* Copyright (c) 2021 Omar Polo <op@omarpolo.com>
003
2021-01-16
op
*
004
2021-01-16
op
* Permission to use, copy, modify, and distribute this software for any
005
2021-01-16
op
* purpose with or without fee is hereby granted, provided that the above
006
2021-01-16
op
* copyright notice and this permission notice appear in all copies.
007
2021-01-16
op
*
008
2021-01-16
op
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
009
2021-01-16
op
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
010
2021-01-16
op
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
011
2021-01-16
op
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
012
2021-01-16
op
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
013
2021-01-16
op
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
014
2021-01-16
op
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
015
2021-01-16
op
*/
016
2021-02-12
op
017
2021-02-12
op
#include "gmid.h"
018
2021-01-16
op
019
2021-05-09
op
#include <sys/un.h>
020
2021-05-09
op
021
2021-01-16
op
#include <err.h>
022
2021-01-16
op
#include <errno.h>
023
2021-01-16
op
024
2021-03-03
op
#include <event.h>
025
2021-01-16
op
#include <fcntl.h>
026
2021-02-01
op
#include <libgen.h>
027
2021-02-01
op
#include <limits.h>
028
2021-01-16
op
#include <signal.h>
029
2021-02-01
op
#include <stdarg.h>
030
2021-01-16
op
#include <string.h>
031
2021-01-16
op
032
2021-03-19
op
static void handle_imsg_cgi_req(struct imsgbuf*, struct imsg*, size_t);
033
2021-05-09
op
static void handle_imsg_fcgi_req(struct imsgbuf*, struct imsg*, size_t);
034
2021-12-29
op
static void handle_imsg_conn_req(struct imsgbuf *, struct imsg *, size_t);
035
2021-03-19
op
static void handle_imsg_quit(struct imsgbuf*, struct imsg*, size_t);
036
2021-03-19
op
static void handle_dispatch_imsg(int, short, void*);
037
2021-01-16
op
038
2021-03-19
op
static imsg_handlerfn *handlers[] = {
039
2021-05-09
op
[IMSG_FCGI_REQ] = handle_imsg_fcgi_req,
040
2021-03-19
op
[IMSG_CGI_REQ] = handle_imsg_cgi_req,
041
2021-12-29
op
[IMSG_CONN_REQ] = handle_imsg_conn_req,
042
2021-03-19
op
[IMSG_QUIT] = handle_imsg_quit,
043
2021-03-19
op
};
044
2021-01-16
op
045
2021-01-16
op
static inline void
046
2021-01-16
op
safe_setenv(const char *name, const char *val)
047
2021-01-16
op
{
048
2021-01-16
op
if (val == NULL)
049
2021-01-16
op
val = "";
050
2021-01-16
op
setenv(name, val, 1);
051
2021-01-16
op
}
052
2021-01-16
op
053
2021-02-01
op
static char *
054
2021-02-01
op
xasprintf(const char *fmt, ...)
055
2021-02-01
op
{
056
2021-02-01
op
va_list ap;
057
2021-02-01
op
char *s;
058
2021-02-01
op
059
2021-02-01
op
va_start(ap, fmt);
060
2021-02-01
op
if (vasprintf(&s, fmt, ap) == -1)
061
2021-02-01
op
s = NULL;
062
2021-02-01
op
va_end(ap);
063
2021-02-01
op
064
2021-02-01
op
return s;
065
2021-02-07
op
}
066
2021-02-07
op
067
2021-02-07
op
static void
068
2021-02-07
op
do_exec(const char *ex, const char *spath, char *query)
069
2021-02-07
op
{
070
2021-02-07
op
char **argv, buf[PATH_MAX], *sname, *t;
071
2021-02-07
op
size_t i, n;
072
2021-02-07
op
073
2021-04-20
op
/* restore the default handlers */
074
2021-04-20
op
signal(SIGPIPE, SIG_DFL);
075
2021-04-20
op
signal(SIGCHLD, SIG_DFL);
076
2021-04-20
op
signal(SIGHUP, SIG_DFL);
077
2021-04-20
op
signal(SIGINT, SIG_DFL);
078
2021-04-20
op
signal(SIGTERM, SIG_DFL);
079
2021-04-20
op
080
2021-02-07
op
strlcpy(buf, spath, sizeof(buf));
081
2021-02-07
op
sname = basename(buf);
082
2021-02-07
op
083
2021-02-07
op
if (query == NULL || strchr(query, '=') != NULL) {
084
2021-02-07
op
if ((argv = calloc(2, sizeof(char*))) == NULL)
085
2021-02-07
op
err(1, "calloc");
086
2021-02-07
op
argv[0] = sname;
087
2021-02-07
op
execvp(ex, argv);
088
2021-02-07
op
warn("execvp: %s", argv[0]);
089
2021-02-07
op
return;
090
2021-02-07
op
}
091
2021-02-07
op
092
2021-02-07
op
n = 1;
093
2021-02-07
op
for (t = query ;; t++, n++) {
094
2021-02-07
op
if ((t = strchr(t, '+')) == NULL)
095
2021-02-07
op
break;
096
2021-02-07
op
}
097
2021-02-07
op
098
2021-02-07
op
if ((argv = calloc(n+2, sizeof(char*))) == NULL)
099
2021-02-07
op
err(1, "calloc");
100
2021-02-07
op
101
2021-02-07
op
argv[0] = sname;
102
2021-02-07
op
for (i = 0; i < n; ++i) {
103
2021-02-07
op
t = strchr(query, '+');
104
2021-02-07
op
if (t != NULL)
105
2021-02-07
op
*t = '\0';
106
2021-02-07
op
argv[i+1] = pct_decode_str(query);
107
2021-02-07
op
query = t+1;
108
2021-02-07
op
}
109
2021-02-07
op
110
2021-02-07
op
execvp(ex, argv);
111
2021-02-07
op
warn("execvp: %s", argv[0]);
112
2021-02-07
op
}
113
2021-02-07
op
114
2021-02-07
op
static inline void
115
2021-02-07
op
setenv_time(const char *var, time_t t)
116
2021-02-07
op
{
117
2021-02-07
op
char timebuf[21];
118
2021-02-07
op
struct tm tminfo;
119
2021-02-07
op
120
2021-02-07
op
if (t == -1)
121
2021-02-07
op
return;
122
2021-02-07
op
123
2021-02-07
op
strftime(timebuf, sizeof(timebuf), "%FT%TZ",
124
2021-02-07
op
gmtime_r(&t, &tminfo));
125
2021-02-07
op
setenv(var, timebuf, 1);
126
2021-02-01
op
}
127
2021-02-01
op
128
2021-01-16
op
/* fd or -1 on error */
129
2021-01-16
op
static int
130
2021-04-30
op
launch_cgi(struct iri *iri, struct cgireq *req, struct vhost *vhost,
131
2021-04-30
op
struct location *loc)
132
2021-01-16
op
{
133
2021-07-06
op
int p[2], errp[2]; /* read end, write end */
134
2021-01-16
op
135
2021-10-02
op
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, p) == -1)
136
2021-01-16
op
return -1;
137
2021-10-02
op
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, errp) == -1)
138
2021-07-06
op
return -1;
139
2021-01-16
op
140
2021-01-16
op
switch (fork()) {
141
2021-01-16
op
case -1:
142
2021-07-08
op
log_err(NULL, "fork failed: %s", strerror(errno));
143
2021-07-08
op
close(p[0]);
144
2021-07-08
op
close(p[1]);
145
2021-07-08
op
close(errp[0]);
146
2021-07-08
op
close(errp[1]);
147
2021-01-16
op
return -1;
148
2021-01-16
op
149
2021-01-16
op
case 0: { /* child */
150
2021-02-01
op
char *ex, *pwd;
151
2021-02-01
op
char iribuf[GEMINI_URL_LEN];
152
2021-02-01
op
char path[PATH_MAX];
153
2021-04-28
op
struct envlist *e;
154
2021-01-16
op
155
2021-01-16
op
close(p[0]);
156
2021-01-16
op
if (dup2(p[1], 1) == -1)
157
2021-01-16
op
goto childerr;
158
2021-01-16
op
159
2021-07-06
op
close(errp[0]);
160
2021-07-06
op
if (dup2(errp[1], 2) == -1)
161
2021-07-06
op
goto childerr;
162
2021-07-06
op
163
2021-04-30
op
ex = xasprintf("%s/%s", loc->dir, req->spath);
164
2021-01-16
op
165
2021-02-01
op
serialize_iri(iri, iribuf, sizeof(iribuf));
166
2021-01-16
op
167
2021-01-16
op
safe_setenv("GATEWAY_INTERFACE", "CGI/1.1");
168
2021-04-30
op
safe_setenv("GEMINI_DOCUMENT_ROOT", loc->dir);
169
2021-02-01
op
safe_setenv("GEMINI_SCRIPT_FILENAME",
170
2021-04-30
op
xasprintf("%s/%s", loc->dir, req->spath));
171
2021-02-01
op
safe_setenv("GEMINI_URL", iribuf);
172
2021-01-16
op
173
2021-02-01
op
strlcpy(path, "/", sizeof(path));
174
2021-03-19
op
strlcat(path, req->spath, sizeof(path));
175
2021-02-01
op
safe_setenv("GEMINI_URL_PATH", path);
176
2021-01-16
op
177
2021-03-19
op
if (*req->relpath != '\0') {
178
2021-02-01
op
strlcpy(path, "/", sizeof(path));
179
2021-03-19
op
strlcat(path, req->relpath, sizeof(path));
180
2021-02-01
op
safe_setenv("PATH_INFO", path);
181
2021-02-01
op
182
2021-04-30
op
strlcpy(path, loc->dir, sizeof(path));
183
2021-02-01
op
strlcat(path, "/", sizeof(path));
184
2021-03-19
op
strlcat(path, req->relpath, sizeof(path));
185
2021-02-01
op
safe_setenv("PATH_TRANSLATED", path);
186
2021-02-01
op
}
187
2021-02-01
op
188
2021-02-01
op
safe_setenv("QUERY_STRING", iri->query);
189
2021-03-19
op
safe_setenv("REMOTE_ADDR", req->addr);
190
2021-03-19
op
safe_setenv("REMOTE_HOST", req->addr);
191
2021-02-01
op
safe_setenv("REQUEST_METHOD", "");
192
2021-01-16
op
193
2021-02-01
op
strlcpy(path, "/", sizeof(path));
194
2021-03-19
op
strlcat(path, req->spath, sizeof(path));
195
2021-02-01
op
safe_setenv("SCRIPT_NAME", path);
196
2021-02-01
op
197
2021-02-01
op
safe_setenv("SERVER_NAME", iri->host);
198
2021-02-01
op
199
2021-02-01
op
snprintf(path, sizeof(path), "%d", conf.port);
200
2021-02-01
op
safe_setenv("SERVER_PORT", path);
201
2021-02-01
op
202
2021-02-01
op
safe_setenv("SERVER_PROTOCOL", "GEMINI");
203
2021-05-15
op
safe_setenv("SERVER_SOFTWARE", GMID_VERSION);
204
2021-02-01
op
205
2021-03-19
op
if (*req->subject != '\0')
206
2021-01-16
op
safe_setenv("AUTH_TYPE", "Certificate");
207
2021-02-01
op
else
208
2021-02-01
op
safe_setenv("AUTH_TYPE", "");
209
2021-01-24
op
210
2021-03-19
op
safe_setenv("REMOTE_USER", req->subject);
211
2021-03-19
op
safe_setenv("TLS_CLIENT_ISSUER", req->issuer);
212
2021-03-19
op
safe_setenv("TLS_CLIENT_HASH", req->hash);
213
2021-04-13
op
safe_setenv("TLS_VERSION", req->version);
214
2021-04-13
op
safe_setenv("TLS_CIPHER", req->cipher);
215
2021-04-13
op
216
2021-04-13
op
snprintf(path, sizeof(path), "%d", req->cipher_strength);
217
2021-04-13
op
safe_setenv("TLS_CIPHER_STRENGTH", path);
218
2021-04-13
op
219
2021-03-19
op
setenv_time("TLS_CLIENT_NOT_AFTER", req->notafter);
220
2021-03-19
op
setenv_time("TLS_CLIENT_NOT_BEFORE", req->notbefore);
221
2021-02-01
op
222
2021-04-28
op
TAILQ_FOREACH(e, &vhost->env, envs) {
223
2021-04-28
op
safe_setenv(e->name, e->value);
224
2021-04-28
op
}
225
2021-04-28
op
226
2021-02-07
op
strlcpy(path, ex, sizeof(path));
227
2021-02-07
op
228
2021-02-01
op
pwd = dirname(path);
229
2021-02-01
op
if (chdir(pwd)) {
230
2021-02-01
op
warn("chdir");
231
2021-02-01
op
goto childerr;
232
2021-02-01
op
}
233
2021-01-16
op
234
2021-03-19
op
do_exec(ex, req->spath, iri->query);
235
2021-01-16
op
goto childerr;
236
2021-01-16
op
}
237
2021-01-16
op
238
2021-01-16
op
default:
239
2021-01-16
op
close(p[1]);
240
2021-07-08
op
close(errp[0]);
241
2021-07-06
op
close(errp[1]);
242
2021-02-06
op
mark_nonblock(p[0]);
243
2021-01-16
op
return p[0];
244
2021-01-16
op
}
245
2021-01-16
op
246
2021-01-16
op
childerr:
247
2021-01-16
op
dprintf(p[1], "%d internal server error\r\n", TEMP_FAILURE);
248
2021-01-16
op
_exit(1);
249
2021-01-16
op
}
250
2021-01-16
op
251
2021-03-31
op
static struct vhost *
252
2021-03-31
op
host_nth(size_t n)
253
2021-03-31
op
{
254
2021-03-31
op
struct vhost *h;
255
2021-03-31
op
256
2021-03-31
op
TAILQ_FOREACH(h, &hosts, vhosts) {
257
2021-03-31
op
if (n == 0)
258
2021-03-31
op
return h;
259
2021-03-31
op
n--;
260
2021-03-31
op
}
261
2021-03-31
op
262
2021-03-31
op
return NULL;
263
2021-03-31
op
}
264
2021-03-31
op
265
2021-04-30
op
static struct location *
266
2021-04-30
op
loc_nth(struct vhost *vhost, size_t n)
267
2021-04-30
op
{
268
2021-04-30
op
struct location *loc;
269
2021-04-30
op
270
2021-04-30
op
TAILQ_FOREACH(loc, &vhost->locations, locations) {
271
2021-04-30
op
if (n == 0)
272
2021-04-30
op
return loc;
273
2021-04-30
op
n--;
274
2021-04-30
op
}
275
2021-04-30
op
276
2021-04-30
op
return NULL;
277
2021-04-30
op
}
278
2021-04-30
op
279
2021-03-03
op
static void
280
2021-03-19
op
handle_imsg_cgi_req(struct imsgbuf *ibuf, struct imsg *imsg, size_t datalen)
281
2021-01-16
op
{
282
2021-03-31
op
struct vhost *h;
283
2021-04-30
op
struct location *l;
284
2021-03-31
op
struct cgireq req;
285
2021-03-31
op
struct iri iri;
286
2021-03-31
op
int fd;
287
2021-03-03
op
288
2021-03-19
op
if (datalen != sizeof(req))
289
2021-03-19
op
abort();
290
2021-03-19
op
291
2022-03-27
op
memcpy(&req, imsg->data, sizeof(req));
292
2021-03-19
op
293
2021-03-19
op
iri.schema = req.iri_schema_off + req.buf;
294
2021-03-19
op
iri.host = req.iri_host_off + req.buf;
295
2021-03-19
op
iri.port = req.iri_port_off + req.buf;
296
2021-03-19
op
iri.path = req.iri_path_off + req.buf;
297
2021-03-19
op
iri.query = req.iri_query_off + req.buf;
298
2021-03-19
op
iri.fragment = req.iri_fragment_off + req.buf;
299
2021-03-19
op
300
2021-03-19
op
/* patch the query, otherwise do_exec will always pass "" as
301
2021-03-19
op
* first argument to the script. */
302
2021-03-19
op
if (*iri.query == '\0')
303
2021-03-19
op
iri.query = NULL;
304
2021-03-19
op
305
2021-03-31
op
if ((h = host_nth(req.host_off)) == NULL)
306
2021-03-19
op
abort();
307
2021-03-19
op
308
2021-05-15
op
if ((l = loc_nth(h, req.loc_off)) == NULL)
309
2021-04-30
op
abort();
310
2021-04-30
op
311
2021-04-30
op
fd = launch_cgi(&iri, &req, h, l);
312
2021-03-19
op
imsg_compose(ibuf, IMSG_CGI_RES, imsg->hdr.peerid, 0, fd, NULL, 0);
313
2021-03-19
op
imsg_flush(ibuf);
314
2021-05-09
op
}
315
2021-05-09
op
316
2021-05-09
op
static int
317
2021-05-09
op
fcgi_open_prog(struct fcgi *f)
318
2021-05-09
op
{
319
2021-05-09
op
int s[2];
320
2021-05-09
op
pid_t p;
321
2021-05-09
op
322
2021-05-09
op
/* XXX! */
323
2021-05-09
op
324
2021-07-08
op
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, s) == -1)
325
2021-05-09
op
err(1, "socketpair");
326
2021-05-09
op
327
2021-05-09
op
switch (p = fork()) {
328
2021-05-09
op
case -1:
329
2021-05-09
op
err(1, "fork");
330
2021-05-09
op
case 0:
331
2021-05-09
op
close(s[0]);
332
2021-05-09
op
if (dup2(s[1], 0) == -1)
333
2021-05-09
op
err(1, "dup2");
334
2021-05-09
op
execl(f->prog, f->prog, NULL);
335
2021-05-09
op
err(1, "execl %s", f->prog);
336
2021-05-09
op
default:
337
2021-05-09
op
close(s[1]);
338
2021-05-09
op
return s[0];
339
2021-05-09
op
}
340
2021-03-19
op
}
341
2021-03-19
op
342
2021-05-09
op
static int
343
2021-05-09
op
fcgi_open_sock(struct fcgi *f)
344
2021-05-09
op
{
345
2021-05-09
op
struct sockaddr_un addr;
346
2021-05-09
op
int fd;
347
2021-05-09
op
348
2021-05-09
op
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
349
2021-05-09
op
log_err(NULL, "socket: %s", strerror(errno));
350
2021-05-09
op
return -1;
351
2021-05-09
op
}
352
2021-05-09
op
353
2021-05-09
op
memset(&addr, 0, sizeof(addr));
354
2021-05-09
op
addr.sun_family = AF_UNIX;
355
2021-05-09
op
strlcpy(addr.sun_path, f->path, sizeof(addr.sun_path));
356
2021-05-09
op
357
2021-05-09
op
if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
358
2021-05-09
op
log_warn(NULL, "failed to connect to %s: %s", f->path,
359
2021-05-09
op
strerror(errno));
360
2021-05-09
op
close(fd);
361
2021-05-09
op
return -1;
362
2021-05-09
op
}
363
2021-05-09
op
364
2021-05-09
op
return fd;
365
2021-05-09
op
}
366
2021-05-09
op
367
2021-05-09
op
static int
368
2021-05-09
op
fcgi_open_conn(struct fcgi *f)
369
2021-05-09
op
{
370
2021-05-09
op
struct addrinfo hints, *servinfo, *p;
371
2021-05-09
op
int r, sock;
372
2021-05-09
op
373
2021-05-09
op
memset(&hints, 0, sizeof(hints));
374
2021-05-09
op
hints.ai_family = AF_UNSPEC;
375
2021-05-09
op
hints.ai_socktype = SOCK_STREAM;
376
2021-05-09
op
hints.ai_flags = AI_ADDRCONFIG;
377
2021-05-09
op
378
2021-05-09
op
if ((r = getaddrinfo(f->path, f->port, &hints, &servinfo)) != 0) {
379
2021-05-09
op
log_warn(NULL, "getaddrinfo %s:%s: %s", f->path, f->port,
380
2021-05-09
op
gai_strerror(r));
381
2021-05-09
op
return -1;
382
2021-05-09
op
}
383
2021-05-09
op
384
2021-05-09
op
for (p = servinfo; p != NULL; p = p->ai_next) {
385
2021-05-09
op
sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
386
2021-05-09
op
if (sock == -1)
387
2021-05-09
op
continue;
388
2021-05-09
op
if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
389
2021-05-09
op
close(sock);
390
2021-05-09
op
continue;
391
2021-05-09
op
}
392
2021-05-09
op
break;
393
2021-05-09
op
}
394
2021-05-09
op
395
2021-05-09
op
if (p == NULL) {
396
2021-05-09
op
log_warn(NULL, "couldn't connect to %s:%s", f->path, f->port);
397
2021-05-09
op
sock = -1;
398
2021-05-09
op
}
399
2021-05-09
op
400
2021-05-09
op
freeaddrinfo(servinfo);
401
2021-05-09
op
return sock;
402
2021-05-09
op
}
403
2021-05-09
op
404
2021-03-19
op
static void
405
2021-05-09
op
handle_imsg_fcgi_req(struct imsgbuf *ibuf, struct imsg *imsg, size_t datalen)
406
2021-05-09
op
{
407
2021-05-09
op
struct fcgi *f;
408
2021-05-09
op
int id, fd;
409
2021-05-09
op
410
2021-05-09
op
if (datalen != sizeof(id))
411
2021-05-09
op
abort();
412
2022-03-27
op
memcpy(&id, imsg->data, sizeof(id));
413
2021-05-09
op
414
2021-05-09
op
if (id > FCGI_MAX || (fcgi[id].path == NULL && fcgi[id].prog == NULL))
415
2021-05-09
op
abort();
416
2021-05-09
op
417
2021-05-09
op
f = &fcgi[id];
418
2021-05-09
op
if (f->prog != NULL)
419
2021-05-09
op
fd = fcgi_open_prog(f);
420
2021-05-09
op
else if (f->port != NULL)
421
2021-05-09
op
fd = fcgi_open_conn(f);
422
2021-05-09
op
else
423
2021-05-09
op
fd = fcgi_open_sock(f);
424
2021-05-09
op
425
2021-10-07
op
imsg_compose(ibuf, IMSG_FCGI_FD, imsg->hdr.peerid, 0, fd, NULL, 0);
426
2021-12-29
op
imsg_flush(ibuf);
427
2021-12-29
op
}
428
2021-12-29
op
429
2021-12-29
op
static void
430
2021-12-29
op
handle_imsg_conn_req(struct imsgbuf *ibuf, struct imsg *imsg, size_t datalen)
431
2021-12-29
op
{
432
2021-12-29
op
struct addrinfo hints, *res, *res0;
433
2021-12-29
op
struct connreq req;
434
2021-12-29
op
int r, sock;
435
2021-12-29
op
436
2021-12-29
op
if (datalen != sizeof(req))
437
2021-12-29
op
abort();
438
2021-12-29
op
memcpy(&req, imsg->data, sizeof(req));
439
2021-12-29
op
req.flag = 0;
440
2021-12-29
op
441
2021-12-29
op
memset(&hints, 0, sizeof(hints));
442
2021-12-29
op
hints.ai_family = AF_UNSPEC;
443
2021-12-29
op
hints.ai_socktype = SOCK_STREAM;
444
2021-12-29
op
445
2021-12-29
op
/* XXX: do this asynchronously if possible */
446
2021-12-29
op
r = getaddrinfo(req.host, req.port, &hints, &res0);
447
2021-12-29
op
if (r != 0) {
448
2021-12-29
op
log_warn(NULL, "getaddrinfo(\"%s\", \"%s\"): %s",
449
2021-12-29
op
req.host, req.port, gai_strerror(r));
450
2021-12-29
op
goto err;
451
2021-12-29
op
}
452
2021-12-29
op
453
2021-12-29
op
for (res = res0; res; res = res->ai_next) {
454
2021-12-29
op
sock = socket(res->ai_family, res->ai_socktype,
455
2021-12-29
op
res->ai_protocol);
456
2021-12-29
op
if (sock == -1)
457
2021-12-29
op
continue;
458
2021-12-29
op
459
2021-12-29
op
if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
460
2021-12-29
op
close(sock);
461
2021-12-29
op
sock = -1;
462
2021-12-29
op
continue;
463
2021-12-29
op
}
464
2021-12-29
op
465
2021-12-29
op
break;
466
2021-12-29
op
}
467
2021-12-29
op
468
2021-12-29
op
freeaddrinfo(res0);
469
2021-12-29
op
470
2021-12-29
op
if (sock == -1) {
471
2021-12-29
op
log_warn(NULL, "can't connect to %s:%s", req.host,
472
2021-12-29
op
req.port);
473
2021-12-29
op
goto err;
474
2021-12-29
op
}
475
2021-12-29
op
476
2021-12-29
op
imsg_compose(ibuf, IMSG_CONN_FD, imsg->hdr.peerid, 0, sock, NULL, 0);
477
2021-05-09
op
imsg_flush(ibuf);
478
2021-12-29
op
return;
479
2021-12-29
op
480
2021-12-29
op
err:
481
2021-12-29
op
imsg_compose(ibuf, IMSG_CONN_FD, imsg->hdr.peerid, 0, -1, NULL, 0);
482
2021-12-29
op
imsg_flush(ibuf);
483
2021-05-09
op
}
484
2021-05-09
op
485
2021-05-09
op
static void
486
2021-03-19
op
handle_imsg_quit(struct imsgbuf *ibuf, struct imsg *imsg, size_t datalen)
487
2021-03-19
op
{
488
2021-03-19
op
int i;
489
2021-03-19
op
490
2021-03-19
op
for (i = 0; i < conf.prefork; ++i) {
491
2021-03-19
op
imsg_compose(&servibuf[i], IMSG_QUIT, 0, 0, -1, NULL, 0);
492
2021-03-19
op
imsg_flush(&exibuf);
493
2021-03-19
op
close(servibuf[i].fd);
494
2021-03-03
op
}
495
2021-03-03
op
496
2021-03-19
op
event_loopbreak();
497
2021-03-19
op
}
498
2021-03-03
op
499
2021-03-19
op
static void
500
2021-03-19
op
handle_dispatch_imsg(int fd, short ev, void *d)
501
2021-03-19
op
{
502
2021-03-19
op
struct imsgbuf *ibuf = d;
503
2021-03-19
op
dispatch_imsg(ibuf, handlers, sizeof(handlers));
504
2021-03-03
op
}
505
2021-03-03
op
506
2021-03-03
op
int
507
2021-03-19
op
executor_main(struct imsgbuf *ibuf)
508
2021-03-03
op
{
509
2021-03-19
op
struct event evs[PROC_MAX], imsgev;
510
2021-03-03
op
int i;
511
2021-01-25
op
512
2021-03-03
op
event_init();
513
2021-01-16
op
514
2021-03-19
op
if (ibuf != NULL) {
515
2021-03-19
op
event_set(&imsgev, ibuf->fd, EV_READ | EV_PERSIST,
516
2021-03-19
op
handle_dispatch_imsg, ibuf);
517
2021-03-19
op
event_add(&imsgev, NULL);
518
2021-03-19
op
}
519
2021-03-19
op
520
2021-03-03
op
for (i = 0; i < conf.prefork; ++i) {
521
2021-03-19
op
event_set(&evs[i], servibuf[i].fd, EV_READ | EV_PERSIST,
522
2021-03-19
op
handle_dispatch_imsg, &servibuf[i]);
523
2021-03-03
op
event_add(&evs[i], NULL);
524
2021-01-16
op
}
525
2021-01-16
op
526
2021-03-20
op
sandbox_executor_process();
527
2021-03-20
op
528
2021-03-03
op
event_dispatch();
529
2021-02-04
op
530
2021-01-16
op
return 1;
531
2021-01-16
op
}
Omar Polo