1 /*
2  * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
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/tree.h>
19 #include <sys/socket.h>
20 
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
23 
24 #include <errno.h>
25 #include <event.h>
26 #include <limits.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <stdint.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include "log.h"
35 #include "tmpl.h"
36 
37 #include "galileo.h"
38 
39 #define MIN(a, b)	((a) < (b) ? (a) : (b))
40 
41 struct fcgi_header {
42 	unsigned char version;
43 	unsigned char type;
44 	unsigned char req_id1;
45 	unsigned char req_id0;
46 	unsigned char content_len1;
47 	unsigned char content_len0;
48 	unsigned char padding;
49 	unsigned char reserved;
50 } __attribute__((packed));
51 
52 /*
53  * number of bytes in a FCGI_HEADER.  Future version of the protocol
54  * will not reduce this number.
55  */
56 #define FCGI_HEADER_LEN	8
57 
58 /*
59  * values for the version component
60  */
61 #define FCGI_VERSION_1	1
62 
63 /*
64  * values for the type component
65  */
66 #define FCGI_BEGIN_REQUEST	 1
67 #define FCGI_ABORT_REQUEST	 2
68 #define FCGI_END_REQUEST	 3
69 #define FCGI_PARAMS		 4
70 #define FCGI_STDIN		 5
71 #define FCGI_STDOUT		 6
72 #define FCGI_STDERR		 7
73 #define FCGI_DATA		 8
74 #define FCGI_GET_VALUES		 9
75 #define FCGI_GET_VALUES_RESULT	10
76 #define FCGI_UNKNOWN_TYPE	11
77 #define FCGI_MAXTYPE		(FCGI_UNKNOWN_TYPE)
78 
79 struct fcgi_begin_req {
80 	unsigned char role1;
81 	unsigned char role0;
82 	unsigned char flags;
83 	unsigned char reserved[5];
84 };
85 
86 struct fcgi_begin_req_record {
87 	struct fcgi_header	header;
88 	struct fcgi_begin_req	body;
89 };
90 
91 /*
92  * mask for flags;
93  */
94 #define FCGI_KEEP_CONN		1
95 
96 /*
97  * values for the role
98  */
99 #define FCGI_RESPONDER	1
100 #define FCGI_AUTHORIZER	2
101 #define FCGI_FILTER	3
102 
103 struct fcgi_end_req_body {
104 	unsigned char app_status3;
105 	unsigned char app_status2;
106 	unsigned char app_status1;
107 	unsigned char app_status0;
108 	unsigned char proto_status;
109 	unsigned char reserved[3];
110 };
111 
112 /*
113  * values for proto_status
114  */
115 #define FCGI_REQUEST_COMPLETE	0
116 #define FCGI_CANT_MPX_CONN	1
117 #define FCGI_OVERLOADED		2
118 #define FCGI_UNKNOWN_ROLE	3
119 
120 /*
121  * Variable names for FCGI_GET_VALUES / FCGI_GET_VALUES_RESULT
122  * records.
123  */
124 #define FCGI_MAX_CONNS	"FCGI_MAX_CONNS"
125 #define FCGI_MAX_REQS	"FCGI_MAX_REQS"
126 #define FCGI_MPXS_CONNS	"FCGI_MPXS_CONNS"
127 
128 #define CAT(f0, f1)	((f0) + ((f1) << 8))
129 
130 enum {
131 	FCGI_RECORD_HEADER,
132 	FCGI_RECORD_BODY,
133 };
134 
135 volatile int fcgi_inflight;
136 
137 static int
138 fcgi_send_end_req(struct fcgi *fcgi, int id, int as, int ps)
139 {
140 	struct bufferevent	*bev = fcgi->fcg_bev;
141 	struct fcgi_header	 hdr;
142 	struct fcgi_end_req_body end;
143 
144 	memset(&hdr, 0, sizeof(hdr));
145 	memset(&end, 0, sizeof(end));
146 
147 	hdr.version = FCGI_VERSION_1;
148 	hdr.type = FCGI_END_REQUEST;
149 	hdr.req_id0 = (id & 0xFF);
150 	hdr.req_id1 = (id >> 8);
151 	hdr.content_len0 = sizeof(end);
152 
153 	end.app_status0 = (unsigned char)as;
154 	end.proto_status = (unsigned char)ps;
155 
156 	if (bufferevent_write(bev, &hdr, sizeof(hdr)) == -1)
157 		return (-1);
158 	if (bufferevent_write(bev, &end, sizeof(end)) == -1)
159 		return (-1);
160 	return (0);
161 }
162 
163 static int
164 end_request(struct client *clt, int status, int proto_status)
165 {
166 	struct fcgi		*fcgi = clt->clt_fcgi;
167 	int			 r;
168 
169 	if (clt_flush(clt) == -1)
170 		return (-1);
171 
172 	r = fcgi_send_end_req(fcgi, clt->clt_id, status,
173 	    proto_status);
174 	if (r == -1) {
175 		fcgi_error(fcgi->fcg_bev, EV_WRITE, fcgi);
176 		return (-1);
177 	}
178 
179 	SPLAY_REMOVE(client_tree, &fcgi->fcg_clients, clt);
180 	proxy_client_free(clt);
181 
182 	if (!fcgi->fcg_keep_conn)
183 		fcgi->fcg_done = 1;
184 
185 	return (0);
186 }
187 
188 int
189 fcgi_end_request(struct client *clt, int status)
190 {
191 	return (end_request(clt, status, FCGI_REQUEST_COMPLETE));
192 }
193 
194 int
195 fcgi_abort_request(struct client *clt)
196 {
197 	return (end_request(clt, 1, FCGI_OVERLOADED));
198 }
199 
200 static void
201 fcgi_inflight_dec(const char *why)
202 {
203 	fcgi_inflight--;
204 	log_debug("%s: fcgi inflight decremented, now %d, %s",
205 	    __func__, fcgi_inflight, why);
206 }
207 
208 void
209 fcgi_accept(int fd, short event, void *arg)
210 {
211 	struct galileo		*env = arg;
212 	struct fcgi		*fcgi = NULL;
213 	socklen_t		 slen;
214 	struct sockaddr_storage	 ss;
215 	int			 s = -1;
216 
217 	event_add(&env->sc_evpause, NULL);
218 	if ((event & EV_TIMEOUT))
219 		return;
220 
221 	slen = sizeof(ss);
222 	if ((s = accept_reserve(env->sc_sock_fd, (struct sockaddr *)&ss,
223 	    &slen, FD_RESERVE, &fcgi_inflight)) == -1) {
224 		/*
225 		 * Pause accept if we are out of file descriptors, or
226 		 * libevent will haunt us here too.
227 		 */
228 		if (errno == ENFILE || errno == EMFILE) {
229 			struct timeval evtpause = { 1, 0 };
230 
231 			event_del(&env->sc_evsock);
232 			evtimer_add(&env->sc_evpause, &evtpause);
233 			log_debug("%s: deferring connections", __func__);
234 		}
235 		return;
236 	}
237 
238 	if ((fcgi = calloc(1, sizeof(*fcgi))) == NULL)
239 		goto err;
240 
241 	fcgi->fcg_id = ++proxy_fcg_id;
242 	fcgi->fcg_s = s;
243 	fcgi->fcg_env = env;
244 	fcgi->fcg_want = FCGI_RECORD_HEADER;
245 	fcgi->fcg_toread = sizeof(struct fcgi_header);
246 	SPLAY_INIT(&fcgi->fcg_clients);
247 
248 	/* assume it's enabled until we get a FCGI_BEGIN_REQUEST */
249 	fcgi->fcg_keep_conn = 1;
250 
251 	fcgi->fcg_bev = bufferevent_new(fcgi->fcg_s, fcgi_read, fcgi_write,
252 	    fcgi_error, fcgi);
253 	if (fcgi->fcg_bev == NULL)
254 		goto err;
255 
256 	bufferevent_enable(fcgi->fcg_bev, EV_READ | EV_WRITE);
257 	return;
258 
259 err:
260 	if (s != -1) {
261 		close(s);
262 		free(fcgi);
263 		fcgi_inflight_dec(__func__);
264 	}
265 }
266 
267 static int
268 parse_len(struct fcgi *fcgi, struct evbuffer *src)
269 {
270 	unsigned char		 c, x[3];
271 
272 	fcgi->fcg_toread--;
273 	evbuffer_remove(src, &c, 1);
274 	if (c >> 7 == 0)
275 		return (c);
276 
277 	if (fcgi->fcg_toread < 3)
278 		return (-1);
279 
280 	fcgi->fcg_toread -= 3;
281 	evbuffer_remove(src, x, sizeof(x));
282 	return (((c & 0x7F) << 24) | (x[0] << 16) | (x[1] << 8) | x[2]);
283 }
284 
285 static int
286 fcgi_parse_params(struct fcgi *fcgi, struct evbuffer *src, struct client *clt)
287 {
288 	char			 pname[32];
289 	char			 server[HOST_NAME_MAX + 1];
290 	char			 path[PATH_MAX];
291 	int			 nlen, vlen;
292 
293 	while (fcgi->fcg_toread > 0) {
294 		if ((nlen = parse_len(fcgi, src)) < 0 ||
295 		    (vlen = parse_len(fcgi, src)) < 0)
296 			return (-1);
297 
298 		if (fcgi->fcg_toread < nlen + vlen)
299 			return (-1);
300 
301 		if ((size_t)nlen > sizeof(pname) - 1) {
302 			/* ignore this parameter */
303 			fcgi->fcg_toread -= nlen - vlen;
304 			evbuffer_drain(src, nlen + vlen);
305 			continue;
306 		}
307 
308 		fcgi->fcg_toread -= nlen;
309 		evbuffer_remove(src, &pname, nlen);
310 		pname[nlen] = '\0';
311 
312 		if (!strcmp(pname, "SERVER_NAME") &&
313 		    (size_t)vlen < sizeof(server)) {
314 			fcgi->fcg_toread -= vlen;
315 			evbuffer_remove(src, &server, vlen);
316 			server[vlen] = '\0';
317 
318 			free(clt->clt_server_name);
319 			if ((clt->clt_server_name = strdup(server)) == NULL)
320 				return (-1);
321 			log_debug("clt %d: server_name: %s", clt->clt_id,
322 			    clt->clt_server_name);
323 			continue;
324 		}
325 
326 		if (!strcmp(pname, "SCRIPT_NAME") &&
327 		    (size_t)vlen < sizeof(path)) {
328 			fcgi->fcg_toread -= vlen;
329 			evbuffer_remove(src, &path, vlen);
330 			path[vlen] = '\0';
331 
332 			free(clt->clt_script_name);
333 			clt->clt_script_name = NULL;
334 
335 			if (vlen > 0 && path[vlen - 1] != '/')
336 				asprintf(&clt->clt_script_name, "%s/", path);
337 			else
338 				clt->clt_script_name = strdup(path);
339 
340 			if (clt->clt_script_name == NULL)
341 				return (-1);
342 
343 			log_debug("clt %d: script_name: %s", clt->clt_id,
344 			    clt->clt_script_name);
345 			continue;
346 		}
347 
348 		if (!strcmp(pname, "PATH_INFO") &&
349 		    (size_t)vlen < sizeof(path)) {
350 			fcgi->fcg_toread -= vlen;
351 			evbuffer_remove(src, &path, vlen);
352 			path[vlen] = '\0';
353 
354 			free(clt->clt_path_info);
355 			clt->clt_path_info = NULL;
356 
357 			if (*path != '/')
358 				asprintf(&clt->clt_path_info, "/%s", path);
359 			else
360 				clt->clt_path_info = strdup(path);
361 
362 			if (clt->clt_path_info == NULL)
363 				return (-1);
364 
365 			log_debug("clt %d: path_info: %s", clt->clt_id,
366 			    clt->clt_path_info);
367 			continue;
368 		}
369 
370 		fcgi->fcg_toread -= vlen;
371 		evbuffer_drain(src, vlen);
372 	}
373 
374 	return (0);
375 }
376 
377 void
378 fcgi_read(struct bufferevent *bev, void *d)
379 {
380 	struct fcgi		*fcgi = d;
381 	struct galileo		*env = fcgi->fcg_env;
382 	struct evbuffer		*src = EVBUFFER_INPUT(bev);
383 	struct fcgi_header	 hdr;
384 	struct fcgi_begin_req	 breq;
385 	struct client		*clt, q;
386 	int			 role;
387 
388 	memset(&q, 0, sizeof(q));
389 
390 	for (;;) {
391 		if (EVBUFFER_LENGTH(src) < (size_t)fcgi->fcg_toread)
392 			return;
393 
394 		if (fcgi->fcg_want == FCGI_RECORD_HEADER) {
395 			fcgi->fcg_want = FCGI_RECORD_BODY;
396 			bufferevent_read(bev, &hdr, sizeof(hdr));
397 
398 #ifdef DEBUG
399 			log_warnx("header: v=%d t=%d id=%d len=%d p=%d",
400 			    hdr.version, hdr.type,
401 			    CAT(hdr.req_id0, hdr.req_id1),
402 			    CAT(hdr.content_len0, hdr.content_len1),
403 			    hdr.padding);
404 #endif
405 
406 			if (hdr.version != FCGI_VERSION_1) {
407 				log_warnx("unknown fastcgi version: %d",
408 				    hdr.version);
409 				fcgi_error(bev, EV_READ, d);
410 				return;
411 			}
412 
413 			fcgi->fcg_toread = CAT(hdr.content_len0,
414 			    hdr.content_len1);
415 			if (fcgi->fcg_toread < 0) {
416 				log_warnx("invalid record length: %d",
417 				    fcgi->fcg_toread);
418 				fcgi_error(bev, EV_READ, d);
419 				return;
420 			}
421 
422 			fcgi->fcg_padding = hdr.padding;
423 			if (fcgi->fcg_padding < 0) {
424 				log_warnx("invalid padding: %d",
425 				    fcgi->fcg_padding);
426 				fcgi_error(bev, EV_READ, d);
427 				return;
428 			}
429 
430 			fcgi->fcg_type = hdr.type;
431 			fcgi->fcg_rec_id = CAT(hdr.req_id0, hdr.req_id1);
432 			continue;
433 		}
434 
435 		q.clt_id = fcgi->fcg_rec_id;
436 		clt = SPLAY_FIND(client_tree, &fcgi->fcg_clients, &q);
437 
438 		switch (fcgi->fcg_type) {
439 		case FCGI_BEGIN_REQUEST:
440 			if (sizeof(breq) != fcgi->fcg_toread) {
441 				log_warnx("unexpected size for "
442 				    "FCGI_BEGIN_REQUEST");
443 				fcgi_error(bev, EV_READ, d);
444 				return;
445 			}
446 
447 			evbuffer_remove(src, &breq, sizeof(breq));
448 
449 			role = CAT(breq.role0, breq.role1);
450 			if (role != FCGI_RESPONDER) {
451 				log_warnx("unknown fastcgi role: %d",
452 				    role);
453 				if (fcgi_send_end_req(fcgi, fcgi->fcg_rec_id,
454 				    1, FCGI_UNKNOWN_ROLE) == -1) {
455 					fcgi_error(bev, EV_READ, d);
456 					return;
457 				}
458 				break;
459 			}
460 
461 			if (!fcgi->fcg_keep_conn) {
462 				log_warnx("trying to reuse the fastcgi "
463 				    "socket without marking it as so.");
464 				fcgi_error(bev, EV_READ, d);
465 				return;
466 			}
467 			fcgi->fcg_keep_conn = breq.flags & FCGI_KEEP_CONN;
468 
469 			if (clt != NULL) {
470 				log_warnx("ignoring attemp to re-use an "
471 				    "active request id (%d)",
472 				    fcgi->fcg_rec_id);
473 				break;
474 			}
475 
476 			if ((clt = calloc(1, sizeof(*clt))) == NULL) {
477 				log_warnx("calloc");
478 				break;
479 			}
480 
481 			clt->clt_tp = template(clt, clt_tp_puts, clt_tp_putc);
482 			if (clt->clt_tp == NULL) {
483 				free(clt);
484 				log_warn("template");
485 				break;
486 			}
487 
488 			clt->clt_id = fcgi->fcg_rec_id;
489 			clt->clt_fd = -1;
490 			clt->clt_fcgi = fcgi;
491 			SPLAY_INSERT(client_tree, &fcgi->fcg_clients, clt);
492 			break;
493 		case FCGI_PARAMS:
494 			if (clt == NULL) {
495 				log_warnx("got FCGI_PARAMS for inactive id "
496 				    "(%d)", fcgi->fcg_rec_id);
497 				evbuffer_drain(src, fcgi->fcg_toread);
498 				break;
499 			}
500 			if (fcgi->fcg_toread == 0) {
501 				evbuffer_drain(src, fcgi->fcg_toread);
502 				proxy_start_request(env, clt);
503 				break;
504 			}
505 			if (fcgi_parse_params(fcgi, src, clt) == -1) {
506 				log_warnx("fcgi_parse_params failed");
507 				fcgi_error(bev, EV_READ, d);
508 				return;
509 			}
510 			break;
511 		case FCGI_STDIN:
512 			/* ignore */
513 			evbuffer_drain(src, fcgi->fcg_toread);
514 			break;
515 		case FCGI_ABORT_REQUEST:
516 			if (clt == NULL) {
517 				log_warnx("got FCGI_ABORT_REQUEST for inactive"
518 				    " id (%d)", fcgi->fcg_rec_id);
519 				evbuffer_drain(src, fcgi->fcg_toread);
520 				break;
521 			}
522 			if (fcgi_end_request(clt, 1) == -1) {
523 				/* calls fcgi_error on failure */
524 				return;
525 			}
526 			break;
527 		default:
528 			log_warnx("unknown fastcgi record type %d",
529 			    fcgi->fcg_type);
530 			evbuffer_drain(src, fcgi->fcg_toread);
531 			break;
532 		}
533 
534 		/* Prepare for the next record. */
535 		evbuffer_drain(src, fcgi->fcg_padding);
536 		fcgi->fcg_want = FCGI_RECORD_HEADER;
537 		fcgi->fcg_toread = sizeof(struct fcgi_header);
538 	}
539 }
540 
541 void
542 fcgi_write(struct bufferevent *bev, void *d)
543 {
544 	struct fcgi		*fcgi = d;
545 	struct evbuffer		*out = EVBUFFER_OUTPUT(bev);
546 
547 	if (fcgi->fcg_done && EVBUFFER_LENGTH(out) == 0)
548 		fcgi_error(bev, EVBUFFER_EOF, fcgi);
549 }
550 
551 void
552 fcgi_error(struct bufferevent *bev, short event, void *d)
553 {
554 	struct fcgi		*fcgi = d;
555 	struct galileo		*env = fcgi->fcg_env;
556 	struct client		*clt;
557 
558 	log_debug("fcgi failure, shutting down connection (ev: %x)",
559 	    event);
560 	fcgi_inflight_dec(__func__);
561 
562 	while ((clt = SPLAY_MIN(client_tree, &fcgi->fcg_clients)) != NULL) {
563 		SPLAY_REMOVE(client_tree, &fcgi->fcg_clients, clt);
564 		proxy_client_free(clt);
565 	}
566 
567 	close(fcgi->fcg_s);
568 	bufferevent_free(fcgi->fcg_bev);
569 	SPLAY_REMOVE(fcgi_tree, &env->sc_fcgi_socks, fcgi);
570 	free(fcgi);
571 
572 	return;
573 }
574 
575 int
576 clt_flush(struct client *clt)
577 {
578 	struct fcgi		*fcgi = clt->clt_fcgi;
579 	struct bufferevent	*bev = fcgi->fcg_bev;
580 	struct fcgi_header	 hdr;
581 
582 	if (clt->clt_buflen == 0)
583 		return (0);
584 
585 	memset(&hdr, 0, sizeof(hdr));
586 	hdr.version = FCGI_VERSION_1;
587 	hdr.type = FCGI_STDOUT;
588 	hdr.req_id0 = (clt->clt_id & 0xFF);
589 	hdr.req_id1 = (clt->clt_id >> 8);
590 	hdr.content_len0 = (clt->clt_buflen & 0xFF);
591 	hdr.content_len1 = (clt->clt_buflen >> 8);
592 
593 	if (bufferevent_write(bev, &hdr, sizeof(hdr)) == -1 ||
594 	    bufferevent_write(bev, clt->clt_buf, clt->clt_buflen) == -1) {
595 		fcgi_error(bev, EV_WRITE, fcgi);
596 		return (-1);
597 	}
598 
599 	clt->clt_buflen = 0;
600 
601 	return (0);
602 }
603 
604 int
605 clt_write(struct client *clt, const uint8_t *buf, size_t len)
606 {
607 	size_t			 left, copy;
608 
609 	while (len > 0) {
610 		left = sizeof(clt->clt_buf) - clt->clt_buflen;
611 		if (left == 0) {
612 			if (clt_flush(clt) == -1)
613 				return (-1);
614 			left = sizeof(clt->clt_buf);
615 		}
616 
617 		copy = MIN(left, len);
618 
619 		memcpy(&clt->clt_buf[clt->clt_buflen], buf, copy);
620 		clt->clt_buflen += copy;
621 		buf += copy;
622 		len -= copy;
623 	}
624 
625 	return (0);
626 }
627 
628 int
629 clt_putc(struct client *clt, char ch)
630 {
631 	return (clt_write(clt, &ch, 1));
632 }
633 
634 int
635 clt_puts(struct client *clt, const char *str)
636 {
637 	return (clt_write(clt, str, strlen(str)));
638 }
639 
640 int
641 clt_write_bufferevent(struct client *clt, struct bufferevent *bev)
642 {
643 	struct evbuffer		*src = EVBUFFER_INPUT(bev);
644 	size_t			 len, left, copy;
645 
646 	len = EVBUFFER_LENGTH(src);
647 	while (len > 0) {
648 		left = sizeof(clt->clt_buf) - clt->clt_buflen;
649 		if (left == 0) {
650 			if (clt_flush(clt) == -1)
651 				return (-1);
652 			left = sizeof(clt->clt_buf);
653 		}
654 
655 		copy = bufferevent_read(bev, &clt->clt_buf[clt->clt_buflen],
656 		    MIN(left, len));
657 		clt->clt_buflen += copy;
658 
659 		len = EVBUFFER_LENGTH(src);
660 	}
661 
662 	return (0);
663 }
664 
665 int
666 clt_printf(struct client *clt, const char *fmt, ...)
667 {
668 	struct fcgi		*fcgi = clt->clt_fcgi;
669 	struct bufferevent	*bev = fcgi->fcg_bev;
670 	char			*str;
671 	va_list			 ap;
672 	int			 r;
673 
674 	va_start(ap, fmt);
675 	r = vasprintf(&str, fmt, ap);
676 	va_end(ap);
677 	if (r == -1) {
678 		fcgi_error(bev, EV_WRITE, fcgi);
679 		return (-1);
680 	}
681 
682 	r = clt_write(clt, str, r);
683 	free(str);
684 	return (r);
685 }
686 
687 int
688 clt_tp_puts(struct template *tp, const char *str)
689 {
690 	struct client		*clt = tp->tp_arg;
691 
692 	if (clt_puts(clt, str) == -1) {
693 		tp->tp_ret = -1;
694 		return (-1);
695 	}
696 
697 	return (0);
698 }
699 
700 int
701 clt_tp_putc(struct template *tp, int c)
702 {
703 	struct client		*clt = tp->tp_arg;
704 
705 	if (clt_putc(clt, c) == -1) {
706 		tp->tp_ret = -1;
707 		return (-1);
708 	}
709 
710 	return (0);
711 }
712 
713 int
714 fcgi_cmp(struct fcgi *a, struct fcgi *b)
715 {
716 	return ((int)a->fcg_id - b->fcg_id);
717 }
718 
719 int
720 fcgi_client_cmp(struct client *a, struct client *b)
721 {
722 	return ((int)a->clt_id - b->clt_id);
723 }
724 
725 SPLAY_GENERATE(fcgi_tree, fcgi, fcg_nodes, fcgi_cmp);
726 SPLAY_GENERATE(client_tree, client, clt_nodes, fcgi_client_cmp);