Blob

Date:
Message:
Store clients inside a splay tree From day one we've been using a static array of client struct to hold the clients data. This has variuos drawbacks, among which: * reuse of the storage ("shades of heartbleed") * maximum fixed amount of clients connected at the same time * bugs are harder to debug The last point in particular is important because if we mess the client ids, or try to execute some functions (e.g. the various fcgi_*) after a client has been disconnected, it's harder to "see" this "use after free"-tier kind of bug. Now I'm using a splay tree to hold the data about the live connections. Each client' data is managed by malloc. If we try to access a client data after the disconnection we'll probably crash with a SIGSEGV and find the bug is more easy. Performance-wise the connection phase should be faster since we don't have to loop anymore to find an empty spot in the clients array, but some operations could be slightly slower (compare the O(1) access in an array with a SPLAY_FIND operation -- still be faster than O(n) thought.)
Actions:
History | Blame | Raw File
1 /*

2  * Copyright (c) 2020 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  */

17 #ifndef GMID_H

18 #define GMID_H

20 #include "config.h"

22 #include <sys/socket.h>

23 #include <sys/tree.h>

24 #include <sys/types.h>

26 #include <arpa/inet.h>

27 #include <netinet/in.h>

29 #include <dirent.h>

30 #include <limits.h>

31 #include <netdb.h>

32 #include <signal.h>

33 #include <stdio.h>

34 #include <stdlib.h>

35 #include <time.h>

36 #include <tls.h>

37 #include <unistd.h>

39 #include <openssl/x509.h>

41 #if HAVE_EVENT2

42 # include <event2/event.h>

43 # include <event2/event_compat.h>

44 # include <event2/event_struct.h>

45 # include <event2/buffer.h>

46 # include <event2/buffer_compat.h>

47 # include <event2/bufferevent.h>

48 # include <event2/bufferevent_struct.h>

49 # include <event2/bufferevent_compat.h>

50 #else

51 # include <event.h>

52 #endif

54 #define GMID_STRING	"gmid " VERSION

55 #define GMID_VERSION	"gmid/" VERSION

57 #define GEMINI_URL_LEN (1024+3)	/* URL max len + \r\n + \0 */

59 #define SUCCESS		20

60 #define TEMP_REDIRECT	30

61 #define TEMP_FAILURE	40

62 #define CGI_ERROR	42

63 #define NOT_FOUND	51

64 #define PROXY_REFUSED	53

65 #define BAD_REQUEST	59

66 #define CLIENT_CERT_REQ	60

67 #define CERT_NOT_AUTH	61

69 /* maximum hostname and label length, +1 for the NUL-terminator */

70 #define DOMAIN_NAME_LEN	(253+1)

71 #define LABEL_LEN	(63+1)

73 #define FCGI_MAX	32

74 #define PROC_MAX	16

76 struct fcgi {

77 	int		 id;

78 	char		*path;

79 	char		*port;

80 	char		*prog;

81 };

82 extern struct fcgi fcgi[FCGI_MAX];

84 TAILQ_HEAD(lochead, location);

85 struct location {

86 	const char	*match;

87 	const char	*lang;

88 	const char	*default_mime;

89 	const char	*index;

90 	int		 auto_index; /* 0 auto, -1 off, 1 on */

91 	int		 block_code;

92 	const char	*block_fmt;

93 	int		 strip;

94 	X509_STORE	*reqca;

95 	int		 disable_log;

96 	int		 fcgi;

98 	const char	*dir;

99 	int		 dirfd;

101 	TAILQ_ENTRY(location) locations;

102 };

104 TAILQ_HEAD(envhead, envlist);

105 struct envlist {

106 	char		*name;

107 	char		*value;

108 	TAILQ_ENTRY(envlist) envs;

109 };

111 TAILQ_HEAD(aliashead, alist);

112 struct alist {

113 	char		*alias;

114 	TAILQ_ENTRY(alist) aliases;

115 };

117 extern TAILQ_HEAD(vhosthead, vhost) hosts;

118 struct vhost {

119 	const char	*domain;

120 	const char	*cert;

121 	const char	*key;

122 	const char	*cgi;

123 	const char	*entrypoint;

125 	TAILQ_ENTRY(vhost) vhosts;

127 	/*

128 	 * the first location rule is always '*' and holds the default

129 	 * settings for the vhost, then follows the "real" location

130 	 * rules as specified in the configuration.

131 	 */

132 	struct lochead	 locations;

134 	struct envhead	 env;

135 	struct envhead	 params;

136 	struct aliashead aliases;

137 };

139 struct etm {			/* extension to mime */

140 	const char	*mime;

141 	const char	*ext;

142 };

144 struct mime {

145 	struct etm	*t;

146 	size_t		len;

147 	size_t		cap;

148 };

150 struct conf {

151 	/* from command line */

152 	int		 foreground;

153 	int		 verbose;

155 	/* in the config */

156 	int		 port;

157 	int		 ipv6;

158 	uint32_t	 protos;

159 	struct mime	 mime;

160 	char		*chroot;

161 	char		*user;

162 	int		 prefork;

163 };

165 extern const char *config_path;

166 extern struct conf conf;

168 extern struct imsgbuf logibuf, exibuf, servibuf[PROC_MAX];

170 extern int servpipes[PROC_MAX];

172 struct iri {

173 	char		*schema;

174 	char		*host;

175 	char		*port;

176 	uint16_t	 port_no;

177 	char		*path;

178 	char		*query;

179 	char		*fragment;

180 };

182 struct parser {

183 	char		*iri;

184 	struct iri	*parsed;

185 	const char	*err;

186 };

188 typedef void (imsg_handlerfn)(struct imsgbuf*, struct imsg*, size_t);

190 enum {

191 	REQUEST_UNDECIDED,

192 	REQUEST_FILE,

193 	REQUEST_DIR,

194 	REQUEST_CGI,

195 	REQUEST_FCGI,

196 	REQUEST_DONE,

197 };

199 #define IS_INTERNAL_REQUEST(x)	((x) != REQUEST_CGI && (x) != REQUEST_FCGI)

201 struct client {

202 	uint32_t	 id;

203 	struct tls	*ctx;

204 	char		*req;

205 	struct iri	 iri;

206 	char		 domain[DOMAIN_NAME_LEN];

208 	struct bufferevent *bev;

210 	int		 type;

212 	struct bufferevent *cgibev;

214 	char		*header;

216 	int		 code;

217 	const char	*meta;

218 	int		 fd, pfd;

219 	struct dirent	**dir;

220 	int		 dirlen, diroff;

222 	/* big enough to store STATUS + SPACE + META + CRLF */

223 	char		 sbuf[1029];

224 	ssize_t		 len, off;

226 	struct sockaddr_storage	 addr;

227 	struct vhost	*host;	/* host they're talking to */

228 	size_t		 loc;	/* location matched */

230 	SPLAY_ENTRY(client) entry;

231 };

232 SPLAY_HEAD(client_tree_id, client);

233 extern struct client_tree_id clients;

235 struct cgireq {

236 	char		buf[GEMINI_URL_LEN];

238 	size_t		iri_schema_off;

239 	size_t		iri_host_off;

240 	size_t		iri_port_off;

241 	size_t		iri_path_off;

242 	size_t		iri_query_off;

243 	size_t		iri_fragment_off;

244 	int		iri_portno;

246 	char		spath[PATH_MAX+1];

247 	char		relpath[PATH_MAX+1];

248 	char		addr[NI_MAXHOST+1];

250 	/* AFAIK there isn't an upper limit for these two fields. */

251 	char		subject[64+1];

252 	char		issuer[64+1];

254 	char		hash[128+1];

255 	char		version[8];

256 	char		cipher[32];

257 	int		cipher_strength;

258 	time_t		notbefore;

259 	time_t		notafter;

261 	size_t		host_off;

262 	size_t		loc_off;

263 };

265 enum {

266 	FILE_EXISTS,

267 	FILE_EXECUTABLE,

268 	FILE_DIRECTORY,

269 	FILE_MISSING,

270 };

272 enum imsg_type {

273 	IMSG_CGI_REQ,

274 	IMSG_CGI_RES,

275 	IMSG_FCGI_REQ,

276 	IMSG_FCGI_FD,

277 	IMSG_LOG,

278 	IMSG_LOG_REQUEST,

279 	IMSG_LOG_TYPE,

280 	IMSG_QUIT,

281 };

283 /* gmid.c */

284 char		*data_dir(void);

285 void		 load_local_cert(const char*, const char*);

286 void		 load_vhosts(void);

287 int		 make_socket(int, int);

288 void		 setup_tls(void);

289 void		 init_config(void);

290 void		 free_config(void);

291 void		 drop_priv(void);

293 void		 yyerror(const char*, ...);

294 void		 parse_conf(const char*);

295 int		 cmdline_symset(char *);

297 /* log.c */

298 void		 fatal(const char*, ...)

299 	__attribute__((format (printf, 1, 2)))

300 	__attribute__((__noreturn__));

302 #define LOG_ATTR_FMT __attribute__((format (printf, 2, 3)))

303 void		 log_err(struct client*, const char*, ...)	LOG_ATTR_FMT;

304 void		 log_warn(struct client*, const char*, ...)	LOG_ATTR_FMT;

305 void		 log_notice(struct client*, const char*, ...)	LOG_ATTR_FMT;

306 void		 log_info(struct client*, const char*, ...)	LOG_ATTR_FMT;

307 void		 log_debug(struct client*, const char*, ...)	LOG_ATTR_FMT;

308 void		 log_request(struct client*, char*, size_t);

309 int		 logger_main(int, struct imsgbuf*);

311 /* mime.c */

312 void		 init_mime(struct mime*);

313 void		 add_mime(struct mime*, const char*, const char*);

314 void		 load_default_mime(struct mime*);

315 const char	*mime(struct vhost*, const char*);

317 /* server.c */

318 extern int	shutting_down;

319 const char	*vhost_lang(struct vhost*, const char*);

320 const char	*vhost_default_mime(struct vhost*, const char*);

321 const char	*vhost_index(struct vhost*, const char*);

322 int		 vhost_auto_index(struct vhost*, const char*);

323 int		 vhost_block_return(struct vhost*, const char*, int*, const char**);

324 int		 vhost_fastcgi(struct vhost*, const char*);

325 int		 vhost_dirfd(struct vhost*, const char*, size_t*);

326 int		 vhost_strip(struct vhost*, const char*);

327 X509_STORE	*vhost_require_ca(struct vhost*, const char*);

328 int		 vhost_disable_log(struct vhost*, const char*);

330 void		 mark_nonblock(int);

331 void		 client_write(struct bufferevent *, void *);

332 void		 start_reply(struct client*, int, const char*);

333 void		 client_close(struct client *);

334 struct client	*try_client_by_id(int);

335 void		 loop(struct tls*, int, int, struct imsgbuf*);

337 int		 client_tree_cmp(struct client *, struct client *);

338 SPLAY_PROTOTYPE(client_tree_id, client, entry, client_tree_cmp);

340 /* dirs.c */

341 int		 scandir_fd(int, struct dirent***, int(*)(const struct dirent*),

342 		    int(*)(const struct dirent**, const struct dirent**));

343 int		 select_non_dot(const struct dirent*);

344 int		 select_non_dotdot(const struct dirent*);

346 /* ex.c */

347 int		 send_string(int, const char*);

348 int		 recv_string(int, char**);

349 int		 send_iri(int, struct iri*);

350 int		 recv_iri(int, struct iri*);

351 void		 free_recvd_iri(struct iri*);

352 int		 send_vhost(int, struct vhost*);

353 int		 recv_vhost(int, struct vhost**);

354 int		 send_time(int, time_t);

355 int		 recv_time(int, time_t*);

356 int		 send_fd(int, int);

357 int		 recv_fd(int);

358 int		 executor_main(struct imsgbuf*);

360 /* fcgi.c */

361 void		 fcgi_read(struct bufferevent *, void *);

362 void		 fcgi_write(struct bufferevent *, void *);

363 void		 fcgi_error(struct bufferevent *, short, void *);

364 void		 fcgi_req(struct client *);

366 /* sandbox.c */

367 void		 sandbox_server_process(void);

368 void		 sandbox_executor_process(void);

369 void		 sandbox_logger_process(void);

371 /* utf8.c */

372 int		 valid_multibyte_utf8(struct parser*);

373 char		*utf8_nth(char*, size_t);

375 /* iri.c */

376 int		 parse_iri(char*, struct iri*, const char**);

377 int		 serialize_iri(struct iri*, char*, size_t);

378 char		*pct_decode_str(char *);

380 /* puny.c */

381 int		 puny_decode(const char*, char*, size_t, const char**);

383 /* utils.c */

384 void		 block_signals(void);

385 void		 unblock_signals(void);

386 int		 starts_with(const char*, const char*);

387 int		 ends_with(const char*, const char*);

388 ssize_t		 filesize(int);

389 char		*absolutify_path(const char*);

390 char		*xstrdup(const char*);

391 void		*xcalloc(size_t, size_t);

392 void		 gen_certificate(const char*, const char*, const char*);

393 X509_STORE	*load_ca(const char*);

394 int		 validate_against_ca(X509_STORE*, const uint8_t*, size_t);

395 void		 dispatch_imsg(struct imsgbuf*, imsg_handlerfn**, size_t);

397 #endif