?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: implement -s bans
[rb-79.git] / rb79-server.c
blob4532db4a11674adba218bfce1f77678028b73ba1
1 /*
2 * Copyright (c) 2017-2020, De Rais <derais@cock.li>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for
5 * any purpose with or without fee is hereby granted, provided that the
6 * above copyright notice and this permission notice appear in all
7 * copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
16 * PERFORMANCE OF THIS SOFTWARE.
17 */
18 #include <limits.h>
19 #include <locale.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <strings.h>
25 #include <time.h>
26 #include <unistd.h>
27
28 #include <fcgiapp.h>
29
30 #include "macros.h"
31 #include "rb79.h"
32
33 #include "config.h"
34
35 const char *program_name = "rb79-server";
36
37 /* Print out a page saying the request was malformed (400) */
38 static int
39 report_bad_request(FCGX_Request *r, const char *reason)
40 {
41 if (!reason) {
42 reason = "That's not a real request. That's all we know.";
43 }
44
45 FCGX_FPrintF(r->out, BAD_REQUEST_FMT, reason);
46
47 return 0;
48 }
49
50 /* Print out a page saying they failed the CAPTCHA (403) */
51 static int
52 report_bad_challenge(FCGX_Request *r)
53 {
54 FCGX_FPrintF(r->out, BAD_CHALLENGE_FMT);
55
56 return 0;
57 }
58
59 /* Print out a BANNED page (403) */
60 static int
61 report_ban(FCGX_Request *r, char *ban_until, char *ban_reason)
62 {
63 FCGX_FPrintF(r->out, BAN_FMT, UBSAFES(ban_until), UBSAFES(ban_reason));
64
65 return 0;
66 }
67
68 /* Print out a BAD METHOD page (405) */
69 static int
70 report_bad_method(FCGX_Request *r)
71 {
72 FCGX_FPrintF(r->out, BAD_METHOD_FMT);
73
74 return 0;
75 }
76
77 /* Print out a FILE TOO LARGE page (413) */
78 static int
79 report_too_large(FCGX_Request *r, const char *large_thing)
80 {
81 FCGX_FPrintF(r->out, TOO_LARGE_FMT, UBSAFES(large_thing));
82
83 return 0;
84 }
85
86 /* Print out a page saying they're posting too fast (429) */
87 static int
88 report_cooldown(FCGX_Request *r, char *cooldown_length)
89 {
90 FCGX_FPrintF(r->out, COOLDOWN_FMT, UBSAFES(cooldown_length));
91
92 return 0;
93 }
94
95 /* Print out an INTERNAL ERROR page (500) */
96 static int
97 report_internal_error(FCGX_Request *r)
98 {
99 FCGX_FPrintF(r->out, INTERNAL_ERROR_FMT);
100
101 return 0;
102 }
103
104 /* Print out a POST SUCCESSFUL page (200) */
105 static int
106 report_post_successful(FCGX_Request *r, const char *buf)
107 {
108 FCGX_FPrintF(r->out, POST_SUCCESSFUL_FMT, buf);
109
110 return 0;
111 }
112
113 /* Normal POST SUCCESSFUL page, with a redirect back to the given board */
114 static int
115 report_post_successful_with_redir(FCGX_Request *r, const char *board_name)
116 {
117 char *buf = 0;
118 size_t len = snprintf(0, 0, "/%s", board_name);
119 int ret = -1;
120
121 if (len + 1 < len) {
122 ERROR_MESSAGE("overflow");
123 report_internal_error(r);
124 goto done;
125 }
126
127 if (!(buf = malloc(len + 1))) {
128 PERROR_MESSAGE("malloc");
129 report_internal_error(r);
130 goto done;
131 }
132
133 sprintf(buf, "/%s", board_name);
134 ret = report_post_successful(r, buf);
135 done:
136 free(buf);
137
138 return ret;
139 }
140
141 /* Normal POST SUCCESSFUL page, with redirect back to the given thread */
142 static int
143 report_post_successful_no_redir(FCGX_Request *r, const char *board_name, const
144 char *thread)
145 {
146 char *buf = 0;
147 size_t len = snprintf(0, 0, "/%s/res/%s", board_name, thread);
148 int ret = -1;
149
150 if (len + 1 < len) {
151 ERROR_MESSAGE("overflow");
152 report_internal_error(r);
153 goto done;
154 }
155
156 if (!(buf = malloc(len + 1))) {
157 PERROR_MESSAGE("malloc");
158 report_internal_error(r);
159 goto done;
160 }
161
162 sprintf(buf, "/%s/res/%s", board_name, thread);
163 ret = report_post_successful(r, buf);
164 done:
165 free(buf);
166
167 return ret;
168 }
169
170 /* Make sure every board has a page (really only for brand-new boards) */
171 static int
172 board_pages_init(struct configuration *conf)
173 {
174 int ret = -1;
175 uintmax_t *thread_ids = 0;
176 size_t thread_ids_num = 0;
177 size_t board_pages_num = 0;
178
179 for (size_t j = 0; j < conf->boards_num; ++j) {
180 free(thread_ids);
181 thread_ids = 0;
182
183 if (lock_acquire(j) < 0) {
184 goto done;
185 }
186
187 if (db_cull_and_report_threads(j, &thread_ids, &thread_ids_num,
188 &board_pages_num) < 0) {
189 goto done;
190 }
191
192 if (wt_write_board(j, thread_ids, thread_ids_num,
193 board_pages_num) < 0) {
194 goto done;
195 }
196
197 lock_release(j);
198 }
199
200 ret = 0;
201 done:
202 free(thread_ids);
203
204 return ret;
205 }
206
207 /* Free what needs to be freed */
208 static void
209 clean_post_cmd(struct post_cmd *p)
210 {
211 if (!p) {
212 return;
213 }
214
215 free(p->raw.action);
216 free(p->raw.board);
217 free(p->raw.thread);
218 free(p->raw.post);
219 free(p->raw.name);
220 free(p->raw.email);
221 free(p->raw.tripcode);
222 free(p->raw.subject);
223 free(p->raw.comment);
224 free(p->raw.file_name);
225 free(p->raw.file_contents);
226 free(p->raw.challenge_id);
227 free(p->raw.challenge_response);
228 free(p->prepared.name);
229 free(p->prepared.email);
230 free(p->prepared.tripcode);
231 free(p->prepared.subject);
232 free(p->prepared.comment);
233 free(p->prepared.ext);
234 free(p->prepared.file_name);
235 free(p->prepared.system_full_path);
236 free(p->prepared.system_thumb_path);
237 free(p->prepared.file_info);
238 free(p->scannable_comment);
239 free(p->scannable_name);
240 free(p->scannable_email);
241 free(p->scannable_subject);
242 free(p->comment_position_map);
243 free(p->name_position_map);
244 free(p->email_position_map);
245 free(p->subject_position_map);
246 *p = (struct post_cmd) { 0 };
247 }
248
249 /* The bulk of work for processing a post */
250 static void
251 handle_op_or_reply(struct configuration *conf, FCGX_Request *r, struct
252 post_cmd *pc, const char *ip, size_t parent_thread)
253 {
254 char *buf = 0;
255 char *abs_file_path = 0;
256 size_t len = 0;
257 int our_fault = 0;
258 uintmax_t real_thread = 0;
259 int cooldown = 0;
260 int thread_dne = 0;
261 int thread_full = 0;
262 int thread_closed = 0;
263 const struct filetype *f;
264 size_t board_pages_num = 0;
265 uintmax_t *thread_ids = 0;
266 size_t thread_ids_num = 0;
267 uint_fast8_t need_to_unlock = 0;
268
269 if (!parent_thread &&
270 (!pc->raw.file_contents ||
271 !pc->raw.file_contents_len)) {
272 LOG("New thread, yet no file (400)");
273 report_bad_request(r, "New threads must have a file");
274 goto done;
275 }
276
277 /* pc comes in with a bunch of these lens set not-as-desired */
278 if (pc->raw.file_name_len > conf->max_text_len) {
279 LOG("File name length (%zu) larger than max (%zu) (413)",
280 pc->raw.file_name_len, conf->max_text_len);
281 report_too_large(r, "Filename");
282 goto done;
283 }
284
285 if (pc->raw.subject_len > conf->max_text_len) {
286 LOG("Subject length (%zu) larger than max (%zu) (413)",
287 pc->raw.subject_len, conf->max_text_len);
288 report_too_large(r, "Subject text");
289 goto done;
290 }
291
292 if (pc->raw.email_len > conf->max_text_len) {
293 LOG("Email length (%zu) larger than max (%zu) (413)",
294 pc->raw.email_len, conf->max_text_len);
295 report_too_large(r, "Email address");
296 goto done;
297 }
298
299 if (pc->raw.comment_len > conf->max_text_len) {
300 LOG("Comment length (%zu) larger than max (%zu) (413)",
301 pc->raw.comment_len, conf->max_text_len);
302 report_too_large(r, "Comment text");
303 goto done;
304 }
305
306 if (pc->raw.file_contents_len > conf->max_file_size) {
307 LOG("File size (%zu) larger than max (%zu) (413)",
308 pc->raw.file_contents_len, conf->max_file_size);
309 report_too_large(r, "File size");
310 goto done;
311 }
312
313 if (sf_check_mime_type(pc->raw.file_contents, pc->raw.file_contents_len,
314 &f) < 0) {
315 LOG("Bad MIME check (400)");
316 report_bad_request(r, "Unsupported file type");
317 goto done;
318 }
319
320 /* Calculate tripcodes before HTML-escaping everything */
321 if (tripcodes_calculate(pc) < 0) {
322 LOG("Error in tripcodes_calculate (500)");
323 report_internal_error(r);
324 goto done;
325 }
326
327 /* HTML-escape, wordfilter, linkify */
328 if (st_sanitize_text(pc, &our_fault) < 0) {
329 if (our_fault) {
330 LOG("Error in st_sanitize_text (500)");
331 report_internal_error(r);
332 goto done;
333 }
334
335 LOG("Bad text (400)");
336 LOG("Comment was \"%s\"", UBSAFES(pc->raw.comment));
337 report_bad_request(r, "Disallowed text");
338 goto done;
339 }
340
341 cooldown = pc->prepared.comment_len ?
342 conf->boards[pc->board_idx].text_cooldown :
343 conf->boards[pc->board_idx].blank_cooldown;
344
345 /*
346 * From now on, everything must be under lock, since we
347 * could be touching the filesystem. Strictly, we don't
348 * need to worry about locking for db-only operations, so
349 * this could be delayed a bit.
350 */
351 if (lock_acquire(pc->board_idx) < 0) {
352 LOG("Error in lock_acquire (500)");
353 report_internal_error(r);
354 goto done;
355 }
356
357 need_to_unlock = 1;
358
359 if (db_insert_post(ip, parent_thread, cooldown, pc, &thread_dne,
360 &thread_closed, &thread_full, &pc->prepared.id) <
361 0) {
362 LOG("Error in insert_post (500)");
363 report_internal_error(r);
364 goto done;
365 }
366
367 LOG("Post %ju on board /%s/", pc->prepared.id,
368 conf->boards[pc->board_idx].name);
369
370 if (thread_dne) {
371 LOG("Thread %zu does not exist (400)", (size_t) 0);
372 report_bad_request(r, "Thread does not exist");
373 goto done;
374 }
375
376 if (thread_full) {
377 LOG("Thread %zu is full (400)", (size_t) 0);
378 report_bad_request(r, "Thread is full");
379 goto done;
380 }
381
382 if (thread_closed) {
383 LOG("Thread %zu is closed (400)", (size_t) 0);
384 report_bad_request(r, "Thread is closed");
385 goto done;
386 }
387
388 /* Make thumbnails and insert them */
389 if (f) {
390 if (sf_install_files(pc->board_idx, pc->raw.file_contents,
391 pc->raw.file_contents_len,
392 &pc->prepared.now, f, &abs_file_path,
393 &pc->prepared.system_full_path,
394 &pc->prepared.system_full_path_len,
395 &pc->prepared.system_thumb_path,
396 &pc->prepared.system_thumb_path_len,
397 &our_fault) < 0) {
398 if (our_fault) {
399 LOG("Error in sf_install_files (500)");
400 report_internal_error(r);
401 goto done;
402 }
403
404 LOG("Couldn't install files (400)");
405 report_bad_request(r, "Bad file upload");
406 goto done;
407 }
408
409 /* ... and now that they're inserted, describe them ... */
410 if (sf_describe_file(f->mime_type, abs_file_path,
411 &pc->prepared.file_info,
412 &pc->prepared.file_info_len) < 0) {
413 LOG("Error in sf_describe_file (500)");
414 report_internal_error(r);
415 goto done;
416 }
417
418 /* ... and alert the db about that description. */
419 if (db_update_file_info(pc->board_idx, pc->prepared.id,
420 pc->prepared.file_info,
421 pc->prepared.file_info_len,
422 pc->prepared.system_full_path,
423 pc->prepared.system_full_path_len,
424 pc->prepared.system_thumb_path,
425 pc->prepared.system_thumb_path_len) <
426 0) {
427 LOG("Error in db_update_post_description (500)");
428 report_internal_error(r);
429 goto done;
430 }
431 }
432
433 /*
434 * We're about ready to write out the threads, boards, etc.
435 * Therefore, we must now check for thread culling, and
436 * also calculate how many board pages we need.
437 */
438 if (db_cull_and_report_threads(pc->board_idx, &thread_ids,
439 &thread_ids_num, &board_pages_num) < 0) {
440 LOG("Error in db_cull_and_report_threads (500)");
441 report_internal_error(r);
442 goto done;
443 }
444
445 real_thread = parent_thread ? parent_thread : pc->prepared.id;
446
447 if (wt_write_thread(pc->board_idx, real_thread) < 0) {
448 LOG("Error in wt_write_thread (500)");
449 report_internal_error(r);
450 goto done;
451 }
452
453 if (wt_write_board(pc->board_idx, thread_ids, thread_ids_num,
454 board_pages_num) < 0) {
455 LOG("Error in wt_write_board (500)");
456 report_internal_error(r);
457 goto done;
458 }
459
460 if (pc->raw.email &&
461 !strcmp(pc->raw.email, "noko")) {
462 report_post_successful_no_redir(r, pc->raw.board,
463 pc->raw.thread);
464 } else {
465 report_post_successful_with_redir(r, pc->raw.board);
466 }
467
468 done:
469
470 if (need_to_unlock) {
471 lock_release(pc->board_idx);
472 }
473
474 free(buf);
475 free(abs_file_path);
476 free(thread_ids);
477 }
478
479 /* Rebuild every thread and every board */
480 static void
481 handle_rebuild (struct configuration *conf, FCGX_Request *r)
482 {
483 uint_fast8_t had_errors = util_rebuild(conf);
484
485 FCGX_FPrintF(r->out, "Status: 200\r\nContent-type: text/plain\r\n\r\n"
486 "Rebuild complete%s\n", had_errors ?
487 " with errors" : "");
488
489 return;
490 }
491
492 /* Figure out what they want us to do */
493 static void
494 handle(struct configuration *conf, FCGX_Request *r)
495 {
496 char *p = 0;
497 char *content_type = 0;
498 char *content_len_str = 0;
499 size_t content_len = 0;
500 char *buf_main = 0;
501 size_t buf_main_len = 0;
502 const char *content_type_prefix = "Content-Type: ";
503 struct post_cmd post_cmd = { 0 };
504 const char *ip_raw = FCGX_GetParam("REMOTE_ADDR", r->envp);
505 char *ip = 0;
506 char *ban_reason = 0;
507 char *ban_until = 0;
508 char *cooldown_length = 0;
509 uint_fast8_t found_idx = 0;
510
511 /* In case someone is trying for a time GET, prioritize that */
512 time(&post_cmd.prepared.now);
513 LOG("-----------------------------------------");
514 LOG("Handling post at %zu from %s", (size_t) post_cmd.prepared.now,
515 UBSAFES(ip_raw));
516
517 if (!ip_raw) {
518 LOG("Couldn't get REMOTE_ADDR (500)");
519 report_internal_error(r);
520 goto done;
521 }
522
523 if (util_normalize_ip(ip_raw, &ip) < 0) {
524 LOG("Couldn't normalize ip (500)");
525 report_internal_error(r);
526 goto done;
527 }
528
529 /* You can only POST to /action */
530 if (!(p = FCGX_GetParam("REQUEST_METHOD", r->envp))) {
531 LOG("Couldn't get request method (500)");
532 report_internal_error(r);
533 goto done;
534 }
535
536 if (strcmp(p, "POST")) {
537 LOG("request method was not POST (405)");
538 report_bad_method(r);
539 goto done;
540 }
541
542 /* We have to somehow feed this into multipart */
543 if (!(content_type = FCGX_GetParam("CONTENT_TYPE", r->envp))) {
544 LOG("Can't get CONTENT_TYPE (500)");
545 report_internal_error(r);
546 goto done;
547 }
548
549 if (!(content_len_str = FCGX_GetParam("CONTENT_LENGTH", r->envp))) {
550 LOG("Can't get CONTENT_LENGTH (500)");
551 report_internal_error(r);
552 goto done;
553 }
554
555 content_len = (size_t) strtoll(content_len_str, 0, 0);
556
557 if (content_len > max_form_data_size) {
558 LOG("Buffer would have exceeded %zuB (413)",
559 max_form_data_size);
560 report_too_large(r, "Total POST");
561 goto done;
562 }
563
564 buf_main_len = strlen(content_type_prefix) + strlen(content_type) +
565 strlen("\r\n\r\n") + content_len;
566
567 if (buf_main_len + 1 < buf_main_len) {
568 ERROR_MESSAGE("overflow");
569 goto done;
570 }
571
572 if (!(buf_main = malloc(buf_main_len + 1))) {
573 PERROR_MESSAGE("malloc");
574 goto done;
575 }
576
577 size_t offset = sprintf(buf_main, "%s%s\r\n\r\n", content_type_prefix,
578 content_type);
579
580 /* Try and swallow this thing into a buffer */
581 FCGX_GetStr(buf_main + offset, content_len, r->in);
582
583 /* Okay, we've got it in the buffer */
584 if (multipart_decompose(buf_main, buf_main_len, &post_cmd) < 0) {
585 LOG("Decoding message failed, returning (400)");
586 report_bad_request(r, "Invalid multipart/form-data");
587 goto done;
588 }
589
590 /* Now we can check what they actually wanted us to DO */
591 if (!post_cmd.raw.action) {
592 LOG("No action specified (400)");
593 report_bad_request(r, "You have to give action=something");
594 goto done;
595 } else if (!(strcmp(post_cmd.raw.action, "reply"))) {
596 post_cmd.action_id = REPLY;
597 } else if (!(strcmp(post_cmd.raw.action, "newthread"))) {
598 post_cmd.action_id = NEWTHREAD;
599 } else if (!(strcmp(post_cmd.raw.action, "rebuild"))) {
600 post_cmd.action_id = REBUILD;
601 }
602
603 if (post_cmd.raw.thread) {
604 post_cmd.thread_id = strtoll(post_cmd.raw.thread, 0, 0);
605 }
606
607 if (post_cmd.action_id == NONE) {
608 LOG("Invalid action \"%s\" (400)", post_cmd.raw.action);
609 report_bad_request(r, "That's not a valid action");
610 goto done;
611 }
612
613 /*
614 * XXX: the idea is to only accept REBUILD commmands from
615 * the local machine. Is this necessary and sufficient in
616 * the world of ipv6?
617 */
618 if (post_cmd.action_id == REBUILD) {
619 /* Note that the IP is normalized so we can sort it */
620 if (strcmp(ip, "127.000.000.001") &&
621 strcmp(ip, "000.000.000.000") &&
622 strcmp(ip, "0000:0000:0000:0000:0000:0000:0000:0001")) {
623 LOG("REBUILD requested from invalid ip %s", ip);
624 report_bad_request(r, "You can(not) rebuild");
625 goto done;
626 }
627
628 goto take_action;
629 }
630
631 /* And we can find where they wanted to do it */
632 found_idx = 0;
633
634 if (!post_cmd.raw.board) {
635 LOG("No board specified (400)");
636 report_bad_request(r, "You have to give board=something");
637 goto done;
638 }
639
640 if (post_cmd.action_id == REPLY &&
641 !post_cmd.thread_id) {
642 LOG("Reply, yet no thread (400)");
643 report_bad_request(r, "You have to give thread=something");
644 goto done;
645 }
646
647 for (size_t j = 0; j < conf->boards_num; ++j) {
648 if (!strcmp(post_cmd.raw.board, conf->boards[j].name)) {
649 post_cmd.board_idx = j;
650 found_idx = 1;
651 break;
652 }
653 }
654
655 if (!found_idx) {
656 LOG("Invalid board \"%s\" (400)", post_cmd.raw.board);
657 report_bad_request(r, "That's not a valid board");
658 goto done;
659 }
660
661 int is_banned = 0;
662 int is_secret = 0;
663
664 if (db_check_bans(ip, post_cmd.board_idx, post_cmd.prepared.now,
665 &is_banned, &ban_until, &is_secret, &ban_reason) <
666 0) {
667 LOG("Couldn't determine ban status (500)");
668 report_internal_error(r);
669 goto done;
670 }
671
672 if (is_banned) {
673 if (is_secret) {
674 LOG("Ban[s] (until=\%s\", reason=\"%s\") (200)",
675 ban_until, ban_reason);
676 report_post_successful_with_redir(r,
677 post_cmd.raw.board);
678 goto done;
679 } else {
680 /* This should give HTTP 403 */
681 LOG("Ban (until=\"%s\", reason=\"%s\") (403)",
682 ban_until, ban_reason);
683 report_ban(r, ban_until, ban_reason);
684 goto done;
685 }
686 }
687
688 if (post_cmd.action_id == REPLY ||
689 post_cmd.action_id == NEWTHREAD) {
690 int is_cooled = 0;
691
692 if (db_check_cooldowns(ip, post_cmd.board_idx,
693 post_cmd.prepared.now, &is_cooled,
694 &cooldown_length) < 0) {
695 LOG("Couldn't determine cooldown status (500)");
696 report_internal_error(r);
697 goto done;
698 }
699
700 if (is_cooled) {
701 /* This should give HTTP 429 */
702 LOG("Cooldown triggered (length=\"%s\") (429)",
703 cooldown_length);
704 report_cooldown(r, cooldown_length);
705 goto done;
706 }
707
708 int correct_challenge = 0;
709
710 if (!post_cmd.raw.challenge_id) {
711 LOG("No challenge id given (403)");
712 report_bad_challenge(r);
713 goto done;
714 }
715
716 char *e = 0;
717 size_t challenge_idx = (size_t) strtoll(
718 post_cmd.raw.challenge_id, &e, 0);
719
720 if (e &&
721 *e) {
722 challenge_idx = conf->challenges_num;
723 }
724
725 if (challenge_idx >= conf->challenges_num) {
726 LOG("Bad challenge id \"%s\" given (403)",
727 post_cmd.raw.challenge_id);
728 report_bad_challenge(r);
729 goto done;
730 }
731
732 if (!post_cmd.raw.challenge_response) {
733 LOG("No challenge response given (403)");
734 report_bad_challenge(r);
735 goto done;
736 }
737
738 for (size_t j = 0; j < NUM_CHALLENGE_ANSWERS; ++j) {
739 if (!conf->challenges[challenge_idx].answers[j]) {
740 continue;
741 }
742
743 if (!strcasecmp(post_cmd.raw.challenge_response,
744 conf->challenges[challenge_idx].answers[
745 j])) {
746 correct_challenge = 1;
747 }
748 }
749
750 if (!correct_challenge) {
751 LOG("Incorrect response \"%s\" to challenge %s (403)",
752 post_cmd.raw.challenge_response,
753 post_cmd.raw.challenge_id);
754 LOG("Comment was \"%s\"", UBSAFES(
755 post_cmd.raw.comment));
756 report_bad_challenge(r);
757 goto done;
758 }
759 }
760
761 take_action:
762
763 /* Now we split into specific actions */
764 switch (post_cmd.action_id) {
765 case REPLY:
766 LOG("reply to /%s/%ju", UBSAFES(post_cmd.raw.board),
767 post_cmd.thread_id);
768 handle_op_or_reply(conf, r, &post_cmd, ip, post_cmd.thread_id);
769 break;
770 case NEWTHREAD:
771 LOG("newthread on /%s/", UBSAFES(post_cmd.raw.board));
772 handle_op_or_reply(conf, r, &post_cmd, ip, 0);
773 break;
774 case REBUILD:
775 LOG("rebuild");
776 handle_rebuild(conf, r);
777 break;
778 case NONE:
779 ERROR_MESSAGE("Impossible");
780 report_internal_error(r);
781 break;
782 }
783
784 done:
785 clean_post_cmd(&post_cmd);
786 free(buf_main);
787 free(ban_reason);
788 free(ban_until);
789 free(cooldown_length);
790 }
791
792 /* Do the thing */
793 int
794 main(void)
795 {
796 int ret = 1;
797 FCGX_Request r = { 0 };
798 struct configuration conf = { 0 };
799
800 setlocale(LC_ALL, "");
801
802 /* tedu@ is probably laughing at me right now. Hi! */
803 srand(time(0));
804 conf = (struct configuration) {
805 /* */
806 .static_www_folder = static_www_folder, /* */
807 .work_path = work_path, /* */
808 .temp_dir_template = temp_dir_template, /* */
809 .trip_salt = trip_salt, /* */
810 .trip_salt_len = strlen(trip_salt), /* */
811 .boards = boards, /* */
812 .boards_num = NUM_OF(boards), /* */
813 .max_form_data_size = max_form_data_size, /* */
814 .max_file_size = max_file_size, /* */
815 .max_text_len = max_text_len, /* */
816 .filetypes = filetypes, /* */
817 .filetypes_num = NUM_OF(filetypes), /* */
818 .file_description_prog = file_description_prog, /* */
819 .headers = headers, /* */
820 .headers_num = NUM_OF(headers), /* */
821 .challenges = challenges, /* */
822 .challenges_num = NUM_OF(challenges), /* */
823 .wordfilter_inputs = wordfilter_inputs, /* */
824 .wordfilter_inputs_num = NUM_OF(wordfilter_inputs), /* */
825 .forbidden_inputs = forbidden_inputs, /* */
826 .forbidden_inputs_num = NUM_OF(forbidden_inputs), /* */
827 };
828
829 if (preconditions_check(&conf) < 0) {
830 goto done;
831 }
832
833 if (board_pages_init(&conf) < 0) {
834 goto done;
835 }
836
837 FCGX_Init();
838 FCGX_InitRequest(&r, 0, 0);
839
840 while (FCGX_Accept_r(&r) == 0) {
841 handle(&conf, &r);
842 FCGX_Finish_r(&r);
843 }
844
845 ret = 0;
846 done:
847 clean_dbs();
848 clean_locks();
849 clean_multipart();
850 clean_sanitize_comment();
851 clean_sanitize_file();
852 clean_tripcodes();
853 clean_write_thread();
854
855 return ret;
856 }
RB-79 imageboard