![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_cgi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src|
Return to mod_cgi.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src |
1.1 misho 1: #include "server.h"
2: #include "stat_cache.h"
3: #include "keyvalue.h"
4: #include "log.h"
5: #include "connections.h"
6: #include "joblist.h"
7: #include "http_chunk.h"
8:
9: #include "plugin.h"
10:
11: #include <sys/types.h>
12:
13: #ifdef __WIN32
14: # include <winsock2.h>
15: #else
16: # include <sys/socket.h>
17: # include <sys/wait.h>
18: # include <sys/mman.h>
19: # include <netinet/in.h>
20: # include <arpa/inet.h>
21: #endif
22:
23: #include <unistd.h>
24: #include <errno.h>
25: #include <stdlib.h>
26: #include <string.h>
27: #include <fdevent.h>
28: #include <signal.h>
29: #include <ctype.h>
30: #include <assert.h>
31:
32: #include <stdio.h>
33: #include <fcntl.h>
34:
35: #ifdef HAVE_SYS_FILIO_H
36: # include <sys/filio.h>
37: #endif
38:
39: #include "version.h"
40:
41: enum {EOL_UNSET, EOL_N, EOL_RN};
42:
43: typedef struct {
44: char **ptr;
45:
46: size_t size;
47: size_t used;
48: } char_array;
49:
50: typedef struct {
51: pid_t *ptr;
52: size_t used;
53: size_t size;
54: } buffer_pid_t;
55:
56: typedef struct {
57: array *cgi;
58: unsigned short execute_x_only;
59: } plugin_config;
60:
61: typedef struct {
62: PLUGIN_DATA;
63: buffer_pid_t cgi_pid;
64:
65: buffer *tmp_buf;
66: buffer *parse_response;
67:
68: plugin_config **config_storage;
69:
70: plugin_config conf;
71: } plugin_data;
72:
73: typedef struct {
74: pid_t pid;
75: int fd;
76: int fde_ndx; /* index into the fd-event buffer */
77:
78: connection *remote_conn; /* dumb pointer */
79: plugin_data *plugin_data; /* dumb pointer */
80:
81: buffer *response;
82: buffer *response_header;
83: } handler_ctx;
84:
85: static handler_ctx * cgi_handler_ctx_init(void) {
86: handler_ctx *hctx = calloc(1, sizeof(*hctx));
87:
88: assert(hctx);
89:
90: hctx->response = buffer_init();
91: hctx->response_header = buffer_init();
92:
93: return hctx;
94: }
95:
96: static void cgi_handler_ctx_free(handler_ctx *hctx) {
97: buffer_free(hctx->response);
98: buffer_free(hctx->response_header);
99:
100: free(hctx);
101: }
102:
103: enum {FDEVENT_HANDLED_UNSET, FDEVENT_HANDLED_FINISHED, FDEVENT_HANDLED_NOT_FINISHED, FDEVENT_HANDLED_ERROR};
104:
105: INIT_FUNC(mod_cgi_init) {
106: plugin_data *p;
107:
108: p = calloc(1, sizeof(*p));
109:
110: assert(p);
111:
112: p->tmp_buf = buffer_init();
113: p->parse_response = buffer_init();
114:
115: return p;
116: }
117:
118:
119: FREE_FUNC(mod_cgi_free) {
120: plugin_data *p = p_d;
121: buffer_pid_t *r = &(p->cgi_pid);
122:
123: UNUSED(srv);
124:
125: if (p->config_storage) {
126: size_t i;
127: for (i = 0; i < srv->config_context->used; i++) {
128: plugin_config *s = p->config_storage[i];
129:
130: array_free(s->cgi);
131:
132: free(s);
133: }
134: free(p->config_storage);
135: }
136:
137:
138: if (r->ptr) free(r->ptr);
139:
140: buffer_free(p->tmp_buf);
141: buffer_free(p->parse_response);
142:
143: free(p);
144:
145: return HANDLER_GO_ON;
146: }
147:
148: SETDEFAULTS_FUNC(mod_fastcgi_set_defaults) {
149: plugin_data *p = p_d;
150: size_t i = 0;
151:
152: config_values_t cv[] = {
153: { "cgi.assign", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
154: { "cgi.execute-x-only", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
155: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET}
156: };
157:
158: if (!p) return HANDLER_ERROR;
159:
160: p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
161:
162: for (i = 0; i < srv->config_context->used; i++) {
163: plugin_config *s;
164:
165: s = calloc(1, sizeof(plugin_config));
166: assert(s);
167:
168: s->cgi = array_init();
169: s->execute_x_only = 0;
170:
171: cv[0].destination = s->cgi;
172: cv[1].destination = &(s->execute_x_only);
173:
174: p->config_storage[i] = s;
175:
176: if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
177: return HANDLER_ERROR;
178: }
179: }
180:
181: return HANDLER_GO_ON;
182: }
183:
184:
185: static int cgi_pid_add(server *srv, plugin_data *p, pid_t pid) {
186: int m = -1;
187: size_t i;
188: buffer_pid_t *r = &(p->cgi_pid);
189:
190: UNUSED(srv);
191:
192: for (i = 0; i < r->used; i++) {
193: if (r->ptr[i] > m) m = r->ptr[i];
194: }
195:
196: if (r->size == 0) {
197: r->size = 16;
198: r->ptr = malloc(sizeof(*r->ptr) * r->size);
199: } else if (r->used == r->size) {
200: r->size += 16;
201: r->ptr = realloc(r->ptr, sizeof(*r->ptr) * r->size);
202: }
203:
204: r->ptr[r->used++] = pid;
205:
206: return m;
207: }
208:
209: static int cgi_pid_del(server *srv, plugin_data *p, pid_t pid) {
210: size_t i;
211: buffer_pid_t *r = &(p->cgi_pid);
212:
213: UNUSED(srv);
214:
215: for (i = 0; i < r->used; i++) {
216: if (r->ptr[i] == pid) break;
217: }
218:
219: if (i != r->used) {
220: /* found */
221:
222: if (i != r->used - 1) {
223: r->ptr[i] = r->ptr[r->used - 1];
224: }
225: r->used--;
226: }
227:
228: return 0;
229: }
230:
231: static int cgi_response_parse(server *srv, connection *con, plugin_data *p, buffer *in) {
232: char *ns;
233: const char *s;
234: int line = 0;
235:
236: UNUSED(srv);
237:
238: buffer_copy_string_buffer(p->parse_response, in);
239:
240: for (s = p->parse_response->ptr;
241: NULL != (ns = strchr(s, '\n'));
242: s = ns + 1, line++) {
243: const char *key, *value;
244: int key_len;
245: data_string *ds;
246:
247: /* strip the \n */
248: ns[0] = '\0';
249:
250: if (ns > s && ns[-1] == '\r') ns[-1] = '\0';
251:
252: if (line == 0 &&
253: 0 == strncmp(s, "HTTP/1.", 7)) {
254: /* non-parsed header ... we parse them anyway */
255:
256: if ((s[7] == '1' ||
257: s[7] == '0') &&
258: s[8] == ' ') {
259: int status;
260: /* after the space should be a status code for us */
261:
262: status = strtol(s+9, NULL, 10);
263:
264: if (status >= 100 &&
265: status < 1000) {
266: /* we expected 3 digits and didn't got them */
267: con->parsed_response |= HTTP_STATUS;
268: con->http_status = status;
269: }
270: }
271: } else {
272: /* parse the headers */
273: key = s;
274: if (NULL == (value = strchr(s, ':'))) {
275: /* we expect: "<key>: <value>\r\n" */
276: continue;
277: }
278:
279: key_len = value - key;
280: value += 1;
281:
282: /* skip LWS */
283: while (*value == ' ' || *value == '\t') value++;
284:
285: if (NULL == (ds = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
286: ds = data_response_init();
287: }
288: buffer_copy_string_len(ds->key, key, key_len);
289: buffer_copy_string(ds->value, value);
290:
291: array_insert_unique(con->response.headers, (data_unset *)ds);
292:
293: switch(key_len) {
294: case 4:
295: if (0 == strncasecmp(key, "Date", key_len)) {
296: con->parsed_response |= HTTP_DATE;
297: }
298: break;
299: case 6:
300: if (0 == strncasecmp(key, "Status", key_len)) {
301: con->http_status = strtol(value, NULL, 10);
302: con->parsed_response |= HTTP_STATUS;
303: }
304: break;
305: case 8:
306: if (0 == strncasecmp(key, "Location", key_len)) {
307: con->parsed_response |= HTTP_LOCATION;
308: }
309: break;
310: case 10:
311: if (0 == strncasecmp(key, "Connection", key_len)) {
312: con->response.keep_alive = (0 == strcasecmp(value, "Keep-Alive")) ? 1 : 0;
313: con->parsed_response |= HTTP_CONNECTION;
314: }
315: break;
316: case 14:
317: if (0 == strncasecmp(key, "Content-Length", key_len)) {
318: con->response.content_length = strtol(value, NULL, 10);
319: con->parsed_response |= HTTP_CONTENT_LENGTH;
320: }
321: break;
322: default:
323: break;
324: }
325: }
326: }
327:
328: /* CGI/1.1 rev 03 - 7.2.1.2 */
329: if ((con->parsed_response & HTTP_LOCATION) &&
330: !(con->parsed_response & HTTP_STATUS)) {
331: con->http_status = 302;
332: }
333:
334: return 0;
335: }
336:
337:
338: static int cgi_demux_response(server *srv, handler_ctx *hctx) {
339: plugin_data *p = hctx->plugin_data;
340: connection *con = hctx->remote_conn;
341:
342: while(1) {
343: int n;
344: int toread;
345:
346: #if defined(__WIN32)
347: buffer_prepare_copy(hctx->response, 4 * 1024);
348: #else
349: if (ioctl(con->fd, FIONREAD, &toread) || toread == 0 || toread <= 4*1024) {
350: buffer_prepare_copy(hctx->response, 4 * 1024);
351: } else {
352: if (toread > MAX_READ_LIMIT) toread = MAX_READ_LIMIT;
353: buffer_prepare_copy(hctx->response, toread + 1);
354: }
355: #endif
356:
357: if (-1 == (n = read(hctx->fd, hctx->response->ptr, hctx->response->size - 1))) {
358: if (errno == EAGAIN || errno == EINTR) {
359: /* would block, wait for signal */
360: return FDEVENT_HANDLED_NOT_FINISHED;
361: }
362: /* error */
363: log_error_write(srv, __FILE__, __LINE__, "sdd", strerror(errno), con->fd, hctx->fd);
364: return FDEVENT_HANDLED_ERROR;
365: }
366:
367: if (n == 0) {
368: /* read finished */
369:
370: con->file_finished = 1;
371:
372: /* send final chunk */
373: http_chunk_append_mem(srv, con, NULL, 0);
374: joblist_append(srv, con);
375:
376: return FDEVENT_HANDLED_FINISHED;
377: }
378:
379: hctx->response->ptr[n] = '\0';
380: hctx->response->used = n+1;
381:
382: /* split header from body */
383:
384: if (con->file_started == 0) {
385: int is_header = 0;
386: int is_header_end = 0;
387: size_t last_eol = 0;
388: size_t i;
389:
390: buffer_append_string_buffer(hctx->response_header, hctx->response);
391:
392: /**
393: * we have to handle a few cases:
394: *
395: * nph:
396: *
397: * HTTP/1.0 200 Ok\n
398: * Header: Value\n
399: * \n
400: *
401: * CGI:
402: * Header: Value\n
403: * Status: 200\n
404: * \n
405: *
406: * and different mixes of \n and \r\n combinations
407: *
408: * Some users also forget about CGI and just send a response and hope
409: * we handle it. No headers, no header-content seperator
410: *
411: */
412:
413: /* nph (non-parsed headers) */
414: if (0 == strncmp(hctx->response_header->ptr, "HTTP/1.", 7)) is_header = 1;
415:
416: for (i = 0; !is_header_end && i < hctx->response_header->used - 1; i++) {
417: char c = hctx->response_header->ptr[i];
418:
419: switch (c) {
420: case ':':
421: /* we found a colon
422: *
423: * looks like we have a normal header
424: */
425: is_header = 1;
426: break;
427: case '\n':
428: /* EOL */
429: if (is_header == 0) {
430: /* we got a EOL but we don't seem to got a HTTP header */
431:
432: is_header_end = 1;
433:
434: break;
435: }
436:
437: /**
438: * check if we saw a \n(\r)?\n sequence
439: */
440: if (last_eol > 0 &&
441: ((i - last_eol == 1) ||
442: (i - last_eol == 2 && hctx->response_header->ptr[i - 1] == '\r'))) {
443: is_header_end = 1;
444: break;
445: }
446:
447: last_eol = i;
448:
449: break;
450: }
451: }
452:
453: if (is_header_end) {
454: if (!is_header) {
455: /* no header, but a body */
456:
457: if (con->request.http_version == HTTP_VERSION_1_1) {
458: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
459: }
460:
461: http_chunk_append_mem(srv, con, hctx->response_header->ptr, hctx->response_header->used);
462: joblist_append(srv, con);
463: } else {
464: const char *bstart;
465: size_t blen;
466:
467: /**
468: * i still points to the char after the terminating EOL EOL
469: *
470: * put it on the last \n again
471: */
472: i--;
473:
474: /* the body starts after the EOL */
475: bstart = hctx->response_header->ptr + (i + 1);
476: blen = (hctx->response_header->used - 1) - (i + 1);
477:
478: /* string the last \r?\n */
479: if (i > 0 && (hctx->response_header->ptr[i - 1] == '\r')) {
480: i--;
481: }
482:
483: hctx->response_header->ptr[i] = '\0';
484: hctx->response_header->used = i + 1; /* the string + \0 */
485:
486: /* parse the response header */
487: cgi_response_parse(srv, con, p, hctx->response_header);
488:
489: /* enable chunked-transfer-encoding */
490: if (con->request.http_version == HTTP_VERSION_1_1 &&
491: !(con->parsed_response & HTTP_CONTENT_LENGTH)) {
492: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
493: }
494:
495: if (blen > 0) {
496: http_chunk_append_mem(srv, con, bstart, blen + 1);
497: joblist_append(srv, con);
498: }
499: }
500:
501: con->file_started = 1;
502: }
503: } else {
504: http_chunk_append_mem(srv, con, hctx->response->ptr, hctx->response->used);
505: joblist_append(srv, con);
506: }
507:
508: #if 0
509: log_error_write(srv, __FILE__, __LINE__, "ddss", con->fd, hctx->fd, connection_get_state(con->state), b->ptr);
510: #endif
511: }
512:
513: return FDEVENT_HANDLED_NOT_FINISHED;
514: }
515:
516: static handler_t cgi_connection_close(server *srv, handler_ctx *hctx) {
517: int status;
518: pid_t pid;
519: plugin_data *p;
520: connection *con;
521:
522: if (NULL == hctx) return HANDLER_GO_ON;
523:
524: p = hctx->plugin_data;
525: con = hctx->remote_conn;
526:
527: if (con->mode != p->id) return HANDLER_GO_ON;
528:
529: #ifndef __WIN32
530:
531: /* the connection to the browser went away, but we still have a connection
532: * to the CGI script
533: *
534: * close cgi-connection
535: */
536:
537: if (hctx->fd != -1) {
538: /* close connection to the cgi-script */
539: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
540: fdevent_unregister(srv->ev, hctx->fd);
541:
542: if (close(hctx->fd)) {
543: log_error_write(srv, __FILE__, __LINE__, "sds", "cgi close failed ", hctx->fd, strerror(errno));
544: }
545:
546: hctx->fd = -1;
547: hctx->fde_ndx = -1;
548: }
549:
550: pid = hctx->pid;
551:
552: con->plugin_ctx[p->id] = NULL;
553:
554: /* is this a good idea ? */
555: cgi_handler_ctx_free(hctx);
556:
557: /* if waitpid hasn't been called by response.c yet, do it here */
558: if (pid) {
559: /* check if the CGI-script is already gone */
560: switch(waitpid(pid, &status, WNOHANG)) {
561: case 0:
562: /* not finished yet */
563: #if 0
564: log_error_write(srv, __FILE__, __LINE__, "sd", "(debug) child isn't done yet, pid:", pid);
565: #endif
566: break;
567: case -1:
568: /* */
569: if (errno == EINTR) break;
570:
571: /*
572: * errno == ECHILD happens if _subrequest catches the process-status before
573: * we have read the response of the cgi process
574: *
575: * -> catch status
576: * -> WAIT_FOR_EVENT
577: * -> read response
578: * -> we get here with waitpid == ECHILD
579: *
580: */
581: if (errno == ECHILD) return HANDLER_GO_ON;
582:
583: log_error_write(srv, __FILE__, __LINE__, "ss", "waitpid failed: ", strerror(errno));
584: return HANDLER_ERROR;
585: default:
586: /* Send an error if we haven't sent any data yet */
587: if (0 == con->file_started) {
588: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
589: con->http_status = 500;
590: con->mode = DIRECT;
591: } else {
592: con->file_finished = 1;
593: }
594:
595: if (WIFEXITED(status)) {
596: #if 0
597: log_error_write(srv, __FILE__, __LINE__, "sd", "(debug) cgi exited fine, pid:", pid);
598: #endif
599: return HANDLER_GO_ON;
600: } else {
601: log_error_write(srv, __FILE__, __LINE__, "sd", "cgi died, pid:", pid);
602: return HANDLER_GO_ON;
603: }
604: }
605:
606:
607: kill(pid, SIGTERM);
608:
609: /* cgi-script is still alive, queue the PID for removal */
610: cgi_pid_add(srv, p, pid);
611: }
612: #endif
613: return HANDLER_GO_ON;
614: }
615:
616: static handler_t cgi_connection_close_callback(server *srv, connection *con, void *p_d) {
617: plugin_data *p = p_d;
618:
619: return cgi_connection_close(srv, con->plugin_ctx[p->id]);
620: }
621:
622:
623: static handler_t cgi_handle_fdevent(server *srv, void *ctx, int revents) {
624: handler_ctx *hctx = ctx;
625: connection *con = hctx->remote_conn;
626:
627: joblist_append(srv, con);
628:
629: if (hctx->fd == -1) {
630: log_error_write(srv, __FILE__, __LINE__, "ddss", con->fd, hctx->fd, connection_get_state(con->state), "invalid cgi-fd");
631:
632: return HANDLER_ERROR;
633: }
634:
635: if (revents & FDEVENT_IN) {
636: switch (cgi_demux_response(srv, hctx)) {
637: case FDEVENT_HANDLED_NOT_FINISHED:
638: break;
639: case FDEVENT_HANDLED_FINISHED:
640: /* we are done */
641:
642: #if 0
643: log_error_write(srv, __FILE__, __LINE__, "ddss", con->fd, hctx->fd, connection_get_state(con->state), "finished");
644: #endif
645: cgi_connection_close(srv, hctx);
646:
647: /* if we get a IN|HUP and have read everything don't exec the close twice */
648: return HANDLER_FINISHED;
649: case FDEVENT_HANDLED_ERROR:
650: /* Send an error if we haven't sent any data yet */
651: if (0 == con->file_started) {
652: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
653: con->http_status = 500;
654: con->mode = DIRECT;
655: } else {
656: con->file_finished = 1;
657: }
658:
659: log_error_write(srv, __FILE__, __LINE__, "s", "demuxer failed: ");
660: break;
661: }
662: }
663:
664: if (revents & FDEVENT_OUT) {
665: /* nothing to do */
666: }
667:
668: /* perhaps this issue is already handled */
669: if (revents & FDEVENT_HUP) {
670: /* check if we still have a unfinished header package which is a body in reality */
671: if (con->file_started == 0 &&
672: hctx->response_header->used) {
673: con->file_started = 1;
674: http_chunk_append_mem(srv, con, hctx->response_header->ptr, hctx->response_header->used);
675: joblist_append(srv, con);
676: }
677:
678: if (con->file_finished == 0) {
679: http_chunk_append_mem(srv, con, NULL, 0);
680: joblist_append(srv, con);
681: }
682:
683: con->file_finished = 1;
684:
685: if (chunkqueue_is_empty(con->write_queue)) {
686: /* there is nothing left to write */
687: connection_set_state(srv, con, CON_STATE_RESPONSE_END);
688: } else {
689: /* used the write-handler to finish the request on demand */
690:
691: }
692:
693: # if 0
694: log_error_write(srv, __FILE__, __LINE__, "sddd", "got HUP from cgi", con->fd, hctx->fd, revents);
695: # endif
696:
697: /* rtsigs didn't liked the close */
698: cgi_connection_close(srv, hctx);
699: } else if (revents & FDEVENT_ERR) {
700: con->file_finished = 1;
701:
702: /* kill all connections to the cgi process */
703: cgi_connection_close(srv, hctx);
704: #if 1
705: log_error_write(srv, __FILE__, __LINE__, "s", "cgi-FDEVENT_ERR");
706: #endif
707: return HANDLER_ERROR;
708: }
709:
710: return HANDLER_FINISHED;
711: }
712:
713:
714: static int cgi_env_add(char_array *env, const char *key, size_t key_len, const char *val, size_t val_len) {
715: char *dst;
716:
717: if (!key || !val) return -1;
718:
719: dst = malloc(key_len + val_len + 2);
720: memcpy(dst, key, key_len);
721: dst[key_len] = '=';
722: memcpy(dst + key_len + 1, val, val_len);
723: dst[key_len + 1 + val_len] = '\0';
724:
725: if (env->size == 0) {
726: env->size = 16;
727: env->ptr = malloc(env->size * sizeof(*env->ptr));
728: } else if (env->size == env->used) {
729: env->size += 16;
730: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
731: }
732:
733: env->ptr[env->used++] = dst;
734:
735: return 0;
736: }
737:
738: static int cgi_create_env(server *srv, connection *con, plugin_data *p, buffer *cgi_handler) {
739: pid_t pid;
740:
741: #ifdef HAVE_IPV6
742: char b2[INET6_ADDRSTRLEN + 1];
743: #endif
744:
745: int to_cgi_fds[2];
746: int from_cgi_fds[2];
747: struct stat st;
748:
749: #ifndef __WIN32
750:
751: if (cgi_handler->used > 1) {
752: /* stat the exec file */
753: if (-1 == (stat(cgi_handler->ptr, &st))) {
754: log_error_write(srv, __FILE__, __LINE__, "sbss",
755: "stat for cgi-handler", cgi_handler,
756: "failed:", strerror(errno));
757: return -1;
758: }
759: }
760:
761: if (pipe(to_cgi_fds)) {
762: log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed:", strerror(errno));
763: return -1;
764: }
765:
766: if (pipe(from_cgi_fds)) {
767: close(to_cgi_fds[0]);
768: close(to_cgi_fds[1]);
769: log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed:", strerror(errno));
770: return -1;
771: }
772:
773: /* fork, execve */
774: switch (pid = fork()) {
775: case 0: {
776: /* child */
777: char **args;
778: int argc;
779: int i = 0;
780: char buf[32];
781: size_t n;
782: char_array env;
783: char *c;
784: const char *s;
785: server_socket *srv_sock = con->srv_socket;
786:
787: /* move stdout to from_cgi_fd[1] */
788: close(STDOUT_FILENO);
789: dup2(from_cgi_fds[1], STDOUT_FILENO);
790: close(from_cgi_fds[1]);
791: /* not needed */
792: close(from_cgi_fds[0]);
793:
794: /* move the stdin to to_cgi_fd[0] */
795: close(STDIN_FILENO);
796: dup2(to_cgi_fds[0], STDIN_FILENO);
797: close(to_cgi_fds[0]);
798: /* not needed */
799: close(to_cgi_fds[1]);
800:
801: /* create environment */
802: env.ptr = NULL;
803: env.size = 0;
804: env.used = 0;
805:
806: if (buffer_is_empty(con->conf.server_tag)) {
807: cgi_env_add(&env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_STR_LEN(PACKAGE_DESC));
808: } else {
809: cgi_env_add(&env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_BUF_LEN(con->conf.server_tag));
810: }
811:
812: if (!buffer_is_empty(con->server_name)) {
813: size_t len = con->server_name->used - 1;
814:
815: if (con->server_name->ptr[0] == '[') {
816: const char *colon = strstr(con->server_name->ptr, "]:");
817: if (colon) len = (colon + 1) - con->server_name->ptr;
818: } else {
819: const char *colon = strchr(con->server_name->ptr, ':');
820: if (colon) len = colon - con->server_name->ptr;
821: }
822:
823: cgi_env_add(&env, CONST_STR_LEN("SERVER_NAME"), con->server_name->ptr, len);
824: } else {
825: #ifdef HAVE_IPV6
826: s = inet_ntop(srv_sock->addr.plain.sa_family,
827: srv_sock->addr.plain.sa_family == AF_INET6 ?
828: (const void *) &(srv_sock->addr.ipv6.sin6_addr) :
829: (const void *) &(srv_sock->addr.ipv4.sin_addr),
830: b2, sizeof(b2)-1);
831: #else
832: s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
833: #endif
834: cgi_env_add(&env, CONST_STR_LEN("SERVER_NAME"), s, strlen(s));
835: }
836: cgi_env_add(&env, CONST_STR_LEN("GATEWAY_INTERFACE"), CONST_STR_LEN("CGI/1.1"));
837:
838: s = get_http_version_name(con->request.http_version);
839:
840: cgi_env_add(&env, CONST_STR_LEN("SERVER_PROTOCOL"), s, strlen(s));
841:
842: LI_ltostr(buf,
843: #ifdef HAVE_IPV6
844: ntohs(srv_sock->addr.plain.sa_family == AF_INET6 ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)
845: #else
846: ntohs(srv_sock->addr.ipv4.sin_port)
847: #endif
848: );
849: cgi_env_add(&env, CONST_STR_LEN("SERVER_PORT"), buf, strlen(buf));
850:
851: switch (srv_sock->addr.plain.sa_family) {
852: #ifdef HAVE_IPV6
853: case AF_INET6:
854: s = inet_ntop(srv_sock->addr.plain.sa_family,
855: (const void *) &(srv_sock->addr.ipv6.sin6_addr),
856: b2, sizeof(b2)-1);
857: break;
858: case AF_INET:
859: s = inet_ntop(srv_sock->addr.plain.sa_family,
860: (const void *) &(srv_sock->addr.ipv4.sin_addr),
861: b2, sizeof(b2)-1);
862: break;
863: #else
864: case AF_INET:
865: s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
866: break;
867: #endif
868: default:
869: s = "";
870: break;
871: }
872: cgi_env_add(&env, CONST_STR_LEN("SERVER_ADDR"), s, strlen(s));
873:
874: s = get_http_method_name(con->request.http_method);
875: cgi_env_add(&env, CONST_STR_LEN("REQUEST_METHOD"), s, strlen(s));
876:
877: if (!buffer_is_empty(con->request.pathinfo)) {
878: cgi_env_add(&env, CONST_STR_LEN("PATH_INFO"), CONST_BUF_LEN(con->request.pathinfo));
879: }
880: cgi_env_add(&env, CONST_STR_LEN("REDIRECT_STATUS"), CONST_STR_LEN("200"));
881: if (!buffer_is_empty(con->uri.query)) {
882: cgi_env_add(&env, CONST_STR_LEN("QUERY_STRING"), CONST_BUF_LEN(con->uri.query));
883: }
884: if (!buffer_is_empty(con->request.orig_uri)) {
885: cgi_env_add(&env, CONST_STR_LEN("REQUEST_URI"), CONST_BUF_LEN(con->request.orig_uri));
886: }
887:
888:
889: switch (con->dst_addr.plain.sa_family) {
890: #ifdef HAVE_IPV6
891: case AF_INET6:
892: s = inet_ntop(con->dst_addr.plain.sa_family,
893: (const void *) &(con->dst_addr.ipv6.sin6_addr),
894: b2, sizeof(b2)-1);
895: break;
896: case AF_INET:
897: s = inet_ntop(con->dst_addr.plain.sa_family,
898: (const void *) &(con->dst_addr.ipv4.sin_addr),
899: b2, sizeof(b2)-1);
900: break;
901: #else
902: case AF_INET:
903: s = inet_ntoa(con->dst_addr.ipv4.sin_addr);
904: break;
905: #endif
906: default:
907: s = "";
908: break;
909: }
910: cgi_env_add(&env, CONST_STR_LEN("REMOTE_ADDR"), s, strlen(s));
911:
912: LI_ltostr(buf,
913: #ifdef HAVE_IPV6
914: ntohs(con->dst_addr.plain.sa_family == AF_INET6 ? con->dst_addr.ipv6.sin6_port : con->dst_addr.ipv4.sin_port)
915: #else
916: ntohs(con->dst_addr.ipv4.sin_port)
917: #endif
918: );
919: cgi_env_add(&env, CONST_STR_LEN("REMOTE_PORT"), buf, strlen(buf));
920:
921: if (buffer_is_equal_caseless_string(con->uri.scheme, CONST_STR_LEN("https"))) {
922: cgi_env_add(&env, CONST_STR_LEN("HTTPS"), CONST_STR_LEN("on"));
923: }
924:
925: /* request.content_length < SSIZE_MAX, see request.c */
926: LI_ltostr(buf, con->request.content_length);
927: cgi_env_add(&env, CONST_STR_LEN("CONTENT_LENGTH"), buf, strlen(buf));
928: cgi_env_add(&env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(con->physical.path));
929: cgi_env_add(&env, CONST_STR_LEN("SCRIPT_NAME"), CONST_BUF_LEN(con->uri.path));
930: cgi_env_add(&env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(con->physical.basedir));
931:
932: /* for valgrind */
933: if (NULL != (s = getenv("LD_PRELOAD"))) {
934: cgi_env_add(&env, CONST_STR_LEN("LD_PRELOAD"), s, strlen(s));
935: }
936:
937: if (NULL != (s = getenv("LD_LIBRARY_PATH"))) {
938: cgi_env_add(&env, CONST_STR_LEN("LD_LIBRARY_PATH"), s, strlen(s));
939: }
940: #ifdef __CYGWIN__
941: /* CYGWIN needs SYSTEMROOT */
942: if (NULL != (s = getenv("SYSTEMROOT"))) {
943: cgi_env_add(&env, CONST_STR_LEN("SYSTEMROOT"), s, strlen(s));
944: }
945: #endif
946:
947: for (n = 0; n < con->request.headers->used; n++) {
948: data_string *ds;
949:
950: ds = (data_string *)con->request.headers->data[n];
951:
952: if (ds->value->used && ds->key->used) {
953: size_t j;
954:
955: buffer_reset(p->tmp_buf);
956:
957: if (0 != strcasecmp(ds->key->ptr, "CONTENT-TYPE")) {
958: buffer_copy_string_len(p->tmp_buf, CONST_STR_LEN("HTTP_"));
959: p->tmp_buf->used--; /* strip \0 after HTTP_ */
960: }
961:
962: buffer_prepare_append(p->tmp_buf, ds->key->used + 2);
963:
964: for (j = 0; j < ds->key->used - 1; j++) {
965: char cr = '_';
966: if (light_isalpha(ds->key->ptr[j])) {
967: /* upper-case */
968: cr = ds->key->ptr[j] & ~32;
969: } else if (light_isdigit(ds->key->ptr[j])) {
970: /* copy */
971: cr = ds->key->ptr[j];
972: }
973: p->tmp_buf->ptr[p->tmp_buf->used++] = cr;
974: }
975: p->tmp_buf->ptr[p->tmp_buf->used++] = '\0';
976:
977: cgi_env_add(&env, CONST_BUF_LEN(p->tmp_buf), CONST_BUF_LEN(ds->value));
978: }
979: }
980:
981: for (n = 0; n < con->environment->used; n++) {
982: data_string *ds;
983:
984: ds = (data_string *)con->environment->data[n];
985:
986: if (ds->value->used && ds->key->used) {
987: size_t j;
988:
989: buffer_reset(p->tmp_buf);
990:
991: buffer_prepare_append(p->tmp_buf, ds->key->used + 2);
992:
993: for (j = 0; j < ds->key->used - 1; j++) {
994: char cr = '_';
995: if (light_isalpha(ds->key->ptr[j])) {
996: /* upper-case */
997: cr = ds->key->ptr[j] & ~32;
998: } else if (light_isdigit(ds->key->ptr[j])) {
999: /* copy */
1000: cr = ds->key->ptr[j];
1001: }
1002: p->tmp_buf->ptr[p->tmp_buf->used++] = cr;
1003: }
1004: p->tmp_buf->ptr[p->tmp_buf->used++] = '\0';
1005:
1006: cgi_env_add(&env, CONST_BUF_LEN(p->tmp_buf), CONST_BUF_LEN(ds->value));
1007: }
1008: }
1009:
1010: if (env.size == env.used) {
1011: env.size += 16;
1012: env.ptr = realloc(env.ptr, env.size * sizeof(*env.ptr));
1013: }
1014:
1015: env.ptr[env.used] = NULL;
1016:
1017: /* set up args */
1018: argc = 3;
1019: args = malloc(sizeof(*args) * argc);
1020: i = 0;
1021:
1022: if (cgi_handler->used > 1) {
1023: args[i++] = cgi_handler->ptr;
1024: }
1025: args[i++] = con->physical.path->ptr;
1026: args[i ] = NULL;
1027:
1028: /* search for the last / */
1029: if (NULL != (c = strrchr(con->physical.path->ptr, '/'))) {
1030: *c = '\0';
1031:
1032: /* change to the physical directory */
1033: if (-1 == chdir(con->physical.path->ptr)) {
1034: log_error_write(srv, __FILE__, __LINE__, "ssb", "chdir failed:", strerror(errno), con->physical.path);
1035: }
1036: *c = '/';
1037: }
1038:
1039: /* we don't need the client socket */
1040: for (i = 3; i < 256; i++) {
1041: if (i != srv->errorlog_fd) close(i);
1042: }
1043:
1044: /* exec the cgi */
1045: execve(args[0], args, env.ptr);
1046:
1047: /* log_error_write(srv, __FILE__, __LINE__, "sss", "CGI failed:", strerror(errno), args[0]); */
1048:
1049: /* */
1050: SEGFAULT();
1051: break;
1052: }
1053: case -1:
1054: /* error */
1055: log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed:", strerror(errno));
1056: close(from_cgi_fds[0]);
1057: close(from_cgi_fds[1]);
1058: close(to_cgi_fds[0]);
1059: close(to_cgi_fds[1]);
1060: return -1;
1061: break;
1062: default: {
1063: handler_ctx *hctx;
1064: /* father */
1065:
1066: close(from_cgi_fds[1]);
1067: close(to_cgi_fds[0]);
1068:
1069: if (con->request.content_length) {
1070: chunkqueue *cq = con->request_content_queue;
1071: chunk *c;
1072:
1073: assert(chunkqueue_length(cq) == (off_t)con->request.content_length);
1074:
1075: /* there is content to send */
1076: for (c = cq->first; c; c = cq->first) {
1077: int r = 0;
1078:
1079: /* copy all chunks */
1080: switch(c->type) {
1081: case FILE_CHUNK:
1082:
1083: if (c->file.mmap.start == MAP_FAILED) {
1084: if (-1 == c->file.fd && /* open the file if not already open */
1085: -1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
1086: log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
1087:
1088: close(from_cgi_fds[0]);
1089: close(to_cgi_fds[1]);
1090: return -1;
1091: }
1092:
1093: c->file.mmap.length = c->file.length;
1094:
1095: if (MAP_FAILED == (c->file.mmap.start = mmap(NULL, c->file.mmap.length, PROT_READ, MAP_SHARED, c->file.fd, 0))) {
1096: log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed: ",
1097: strerror(errno), c->file.name, c->file.fd);
1098:
1099: close(from_cgi_fds[0]);
1100: close(to_cgi_fds[1]);
1101: return -1;
1102: }
1103:
1104: close(c->file.fd);
1105: c->file.fd = -1;
1106:
1107: /* chunk_reset() or chunk_free() will cleanup for us */
1108: }
1109:
1110: if ((r = write(to_cgi_fds[1], c->file.mmap.start + c->offset, c->file.length - c->offset)) < 0) {
1111: switch(errno) {
1112: case ENOSPC:
1113: con->http_status = 507;
1114: break;
1115: case EINTR:
1116: continue;
1117: default:
1118: con->http_status = 403;
1119: break;
1120: }
1121: }
1122: break;
1123: case MEM_CHUNK:
1124: if ((r = write(to_cgi_fds[1], c->mem->ptr + c->offset, c->mem->used - c->offset - 1)) < 0) {
1125: switch(errno) {
1126: case ENOSPC:
1127: con->http_status = 507;
1128: break;
1129: case EINTR:
1130: continue;
1131: default:
1132: con->http_status = 403;
1133: break;
1134: }
1135: }
1136: break;
1137: case UNUSED_CHUNK:
1138: break;
1139: }
1140:
1141: if (r > 0) {
1142: c->offset += r;
1143: cq->bytes_out += r;
1144: } else {
1145: log_error_write(srv, __FILE__, __LINE__, "ss", "write() failed due to: ", strerror(errno));
1146: con->http_status = 500;
1147: break;
1148: }
1149: chunkqueue_remove_finished_chunks(cq);
1150: }
1151: }
1152:
1153: close(to_cgi_fds[1]);
1154:
1155: /* register PID and wait for them asyncronously */
1156: con->mode = p->id;
1157: buffer_reset(con->physical.path);
1158:
1159: hctx = cgi_handler_ctx_init();
1160:
1161: hctx->remote_conn = con;
1162: hctx->plugin_data = p;
1163: hctx->pid = pid;
1164: hctx->fd = from_cgi_fds[0];
1165: hctx->fde_ndx = -1;
1166:
1167: con->plugin_ctx[p->id] = hctx;
1168:
1169: fdevent_register(srv->ev, hctx->fd, cgi_handle_fdevent, hctx);
1170: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
1171:
1172: if (-1 == fdevent_fcntl_set(srv->ev, hctx->fd)) {
1173: log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed: ", strerror(errno));
1174:
1175: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
1176: fdevent_unregister(srv->ev, hctx->fd);
1177:
1178: log_error_write(srv, __FILE__, __LINE__, "sd", "cgi close:", hctx->fd);
1179:
1180: close(hctx->fd);
1181:
1182: cgi_handler_ctx_free(hctx);
1183:
1184: con->plugin_ctx[p->id] = NULL;
1185:
1186: return -1;
1187: }
1188:
1189: break;
1190: }
1191: }
1192:
1193: return 0;
1194: #else
1195: return -1;
1196: #endif
1197: }
1198:
1199: #define PATCH(x) \
1200: p->conf.x = s->x;
1201: static int mod_cgi_patch_connection(server *srv, connection *con, plugin_data *p) {
1202: size_t i, j;
1203: plugin_config *s = p->config_storage[0];
1204:
1205: PATCH(cgi);
1206: PATCH(execute_x_only);
1207:
1208: /* skip the first, the global context */
1209: for (i = 1; i < srv->config_context->used; i++) {
1210: data_config *dc = (data_config *)srv->config_context->data[i];
1211: s = p->config_storage[i];
1212:
1213: /* condition didn't match */
1214: if (!config_check_cond(srv, con, dc)) continue;
1215:
1216: /* merge config */
1217: for (j = 0; j < dc->value->used; j++) {
1218: data_unset *du = dc->value->data[j];
1219:
1220: if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.assign"))) {
1221: PATCH(cgi);
1222: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.execute-x-only"))) {
1223: PATCH(execute_x_only);
1224: }
1225: }
1226: }
1227:
1228: return 0;
1229: }
1230: #undef PATCH
1231:
1232: URIHANDLER_FUNC(cgi_is_handled) {
1233: size_t k, s_len;
1234: plugin_data *p = p_d;
1235: buffer *fn = con->physical.path;
1236: stat_cache_entry *sce = NULL;
1237:
1238: if (con->mode != DIRECT) return HANDLER_GO_ON;
1239:
1240: if (fn->used == 0) return HANDLER_GO_ON;
1241:
1242: mod_cgi_patch_connection(srv, con, p);
1243:
1244: if (HANDLER_ERROR == stat_cache_get_entry(srv, con, con->physical.path, &sce)) return HANDLER_GO_ON;
1245: if (!S_ISREG(sce->st.st_mode)) return HANDLER_GO_ON;
1246: if (p->conf.execute_x_only == 1 && (sce->st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) return HANDLER_GO_ON;
1247:
1248: s_len = fn->used - 1;
1249:
1250: for (k = 0; k < p->conf.cgi->used; k++) {
1251: data_string *ds = (data_string *)p->conf.cgi->data[k];
1252: size_t ct_len = ds->key->used - 1;
1253:
1254: if (ds->key->used == 0) continue;
1255: if (s_len < ct_len) continue;
1256:
1257: if (0 == strncmp(fn->ptr + s_len - ct_len, ds->key->ptr, ct_len)) {
1258: if (cgi_create_env(srv, con, p, ds->value)) {
1259: con->mode = DIRECT;
1260: con->http_status = 500;
1261:
1262: buffer_reset(con->physical.path);
1263: return HANDLER_FINISHED;
1264: }
1265: /* one handler is enough for the request */
1266: break;
1267: }
1268: }
1269:
1270: return HANDLER_GO_ON;
1271: }
1272:
1273: TRIGGER_FUNC(cgi_trigger) {
1274: plugin_data *p = p_d;
1275: size_t ndx;
1276: /* the trigger handle only cares about lonely PID which we have to wait for */
1277: #ifndef __WIN32
1278:
1279: for (ndx = 0; ndx < p->cgi_pid.used; ndx++) {
1280: int status;
1281:
1282: switch(waitpid(p->cgi_pid.ptr[ndx], &status, WNOHANG)) {
1283: case 0:
1284: /* not finished yet */
1285: #if 0
1286: log_error_write(srv, __FILE__, __LINE__, "sd", "(debug) child isn't done yet, pid:", p->cgi_pid.ptr[ndx]);
1287: #endif
1288: break;
1289: case -1:
1290: if (errno == ECHILD) {
1291: /* someone else called waitpid... remove the pid to stop looping the error each time */
1292: log_error_write(srv, __FILE__, __LINE__, "s", "cgi child vanished, probably someone else called waitpid");
1293:
1294: cgi_pid_del(srv, p, p->cgi_pid.ptr[ndx]);
1295: ndx--;
1296: continue;
1297: }
1298:
1299: log_error_write(srv, __FILE__, __LINE__, "ss", "waitpid failed: ", strerror(errno));
1300:
1301: return HANDLER_ERROR;
1302: default:
1303:
1304: if (WIFEXITED(status)) {
1305: #if 0
1306: log_error_write(srv, __FILE__, __LINE__, "sd", "(debug) cgi exited fine, pid:", p->cgi_pid.ptr[ndx]);
1307: #endif
1308: } else if (WIFSIGNALED(status)) {
1309: /* FIXME: what if we killed the CGI script with a kill(..., SIGTERM) ?
1310: */
1311: if (WTERMSIG(status) != SIGTERM) {
1312: log_error_write(srv, __FILE__, __LINE__, "sd", "cleaning up CGI: process died with signal", WTERMSIG(status));
1313: }
1314: } else {
1315: log_error_write(srv, __FILE__, __LINE__, "s", "cleaning up CGI: ended unexpectedly");
1316: }
1317:
1318: cgi_pid_del(srv, p, p->cgi_pid.ptr[ndx]);
1319: /* del modified the buffer structure
1320: * and copies the last entry to the current one
1321: * -> recheck the current index
1322: */
1323: ndx--;
1324: }
1325: }
1326: #endif
1327: return HANDLER_GO_ON;
1328: }
1329:
1330: /*
1331: * - HANDLER_GO_ON : not our job
1332: * - HANDLER_FINISHED: got response header
1333: * - HANDLER_WAIT_FOR_EVENT: waiting for response header
1334: */
1335: SUBREQUEST_FUNC(mod_cgi_handle_subrequest) {
1336: int status;
1337: plugin_data *p = p_d;
1338: handler_ctx *hctx = con->plugin_ctx[p->id];
1339:
1340: if (con->mode != p->id) return HANDLER_GO_ON;
1341: if (NULL == hctx) return HANDLER_GO_ON;
1342:
1343: #if 0
1344: log_error_write(srv, __FILE__, __LINE__, "sdd", "subrequest, pid =", hctx, hctx->pid);
1345: #endif
1346:
1347: if (hctx->pid == 0) {
1348: /* cgi already dead */
1349: if (!con->file_started) return HANDLER_WAIT_FOR_EVENT;
1350: return HANDLER_FINISHED;
1351: }
1352:
1353: #ifndef __WIN32
1354: switch(waitpid(hctx->pid, &status, WNOHANG)) {
1355: case 0:
1356: /* we only have for events here if we don't have the header yet,
1357: * otherwise the event-handler will send us the incoming data */
1358: if (con->file_started) return HANDLER_FINISHED;
1359:
1360: return HANDLER_WAIT_FOR_EVENT;
1361: case -1:
1362: if (errno == EINTR) return HANDLER_WAIT_FOR_EVENT;
1363:
1364: if (errno == ECHILD && con->file_started == 0) {
1365: /*
1366: * second round but still not response
1367: */
1368: return HANDLER_WAIT_FOR_EVENT;
1369: }
1370:
1371: log_error_write(srv, __FILE__, __LINE__, "ss", "waitpid failed: ", strerror(errno));
1372: con->mode = DIRECT;
1373: con->http_status = 500;
1374:
1375: hctx->pid = 0;
1376:
1377: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
1378: fdevent_unregister(srv->ev, hctx->fd);
1379:
1380: if (close(hctx->fd)) {
1381: log_error_write(srv, __FILE__, __LINE__, "sds", "cgi close failed ", hctx->fd, strerror(errno));
1382: }
1383:
1384: cgi_handler_ctx_free(hctx);
1385:
1386: con->plugin_ctx[p->id] = NULL;
1387:
1388: return HANDLER_FINISHED;
1389: default:
1390: /* cgi process exited
1391: */
1392:
1393: hctx->pid = 0;
1394:
1395: /* we already have response headers? just continue */
1396: if (con->file_started) return HANDLER_FINISHED;
1397:
1398: if (WIFEXITED(status)) {
1399: /* clean exit - just continue */
1400: return HANDLER_WAIT_FOR_EVENT;
1401: }
1402:
1403: /* cgi proc died, and we didn't get any data yet - send error message and close cgi con */
1404: log_error_write(srv, __FILE__, __LINE__, "s", "cgi died ?");
1405:
1406: con->http_status = 500;
1407: con->mode = DIRECT;
1408:
1409: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
1410: fdevent_unregister(srv->ev, hctx->fd);
1411:
1412: if (close(hctx->fd)) {
1413: log_error_write(srv, __FILE__, __LINE__, "sds", "cgi close failed ", hctx->fd, strerror(errno));
1414: }
1415:
1416: cgi_handler_ctx_free(hctx);
1417:
1418: con->plugin_ctx[p->id] = NULL;
1419: return HANDLER_FINISHED;
1420: }
1421: #else
1422: return HANDLER_ERROR;
1423: #endif
1424: }
1425:
1426:
1427: int mod_cgi_plugin_init(plugin *p);
1428: int mod_cgi_plugin_init(plugin *p) {
1429: p->version = LIGHTTPD_VERSION_ID;
1430: p->name = buffer_init_string("cgi");
1431:
1432: p->connection_reset = cgi_connection_close_callback;
1433: p->handle_subrequest_start = cgi_is_handled;
1434: p->handle_subrequest = mod_cgi_handle_subrequest;
1435: #if 0
1436: p->handle_fdevent = cgi_handle_fdevent;
1437: #endif
1438: p->handle_trigger = cgi_trigger;
1439: p->init = mod_cgi_init;
1440: p->cleanup = mod_cgi_free;
1441: p->set_defaults = mod_fastcgi_set_defaults;
1442:
1443: p->data = NULL;
1444:
1445: return 0;
1446: }