mirror of
https://github.com/cesanta/mongoose.git
synced 2026-10-04 07:04:14 +07:00
Deomid Ryabkov
f33d3a4e02
Fixes https://nvd.nist.gov/vuln/detail/CVE-2018-10945 CL: mg: Fix body length calculation in mg_handle_cgi PUBLISHED_FROM=0c30cf36fdb67c75f6148468701e23d6ee72d953
514 lines
16 KiB
C
514 lines
16 KiB
C
/*
|
|
* Copyright (c) 2014-2016 Cesanta Software Limited
|
|
* All rights reserved
|
|
*/
|
|
|
|
#ifndef _WIN32
|
|
#include <signal.h>
|
|
#endif
|
|
|
|
#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI
|
|
|
|
#ifndef MG_MAX_CGI_ENVIR_VARS
|
|
#define MG_MAX_CGI_ENVIR_VARS 64
|
|
#endif
|
|
|
|
#ifndef MG_ENV_EXPORT_TO_CGI
|
|
#define MG_ENV_EXPORT_TO_CGI "MONGOOSE_CGI"
|
|
#endif
|
|
|
|
#define MG_F_HTTP_CGI_PARSE_HEADERS MG_F_USER_1
|
|
|
|
/*
|
|
* This structure helps to create an environment for the spawned CGI program.
|
|
* Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings,
|
|
* last element must be NULL.
|
|
* However, on Windows there is a requirement that all these VARIABLE=VALUE\0
|
|
* strings must reside in a contiguous buffer. The end of the buffer is
|
|
* marked by two '\0' characters.
|
|
* We satisfy both worlds: we create an envp array (which is vars), all
|
|
* entries are actually pointers inside buf.
|
|
*/
|
|
struct mg_cgi_env_block {
|
|
struct mg_connection *nc;
|
|
char buf[MG_CGI_ENVIRONMENT_SIZE]; /* Environment buffer */
|
|
const char *vars[MG_MAX_CGI_ENVIR_VARS]; /* char *envp[] */
|
|
int len; /* Space taken */
|
|
int nvars; /* Number of variables in envp[] */
|
|
};
|
|
|
|
#ifdef _WIN32
|
|
struct mg_threadparam {
|
|
sock_t s;
|
|
HANDLE hPipe;
|
|
};
|
|
|
|
static int mg_wait_until_ready(sock_t sock, int for_read) {
|
|
fd_set set;
|
|
FD_ZERO(&set);
|
|
FD_SET(sock, &set);
|
|
return select(sock + 1, for_read ? &set : 0, for_read ? 0 : &set, 0, 0) == 1;
|
|
}
|
|
|
|
static void *mg_push_to_stdin(void *arg) {
|
|
struct mg_threadparam *tp = (struct mg_threadparam *) arg;
|
|
int n, sent, stop = 0;
|
|
DWORD k;
|
|
char buf[BUFSIZ];
|
|
|
|
while (!stop && mg_wait_until_ready(tp->s, 1) &&
|
|
(n = recv(tp->s, buf, sizeof(buf), 0)) > 0) {
|
|
if (n == -1 && GetLastError() == WSAEWOULDBLOCK) continue;
|
|
for (sent = 0; !stop && sent < n; sent += k) {
|
|
if (!WriteFile(tp->hPipe, buf + sent, n - sent, &k, 0)) stop = 1;
|
|
}
|
|
}
|
|
DBG(("%s", "FORWARED EVERYTHING TO CGI"));
|
|
CloseHandle(tp->hPipe);
|
|
MG_FREE(tp);
|
|
return NULL;
|
|
}
|
|
|
|
static void *mg_pull_from_stdout(void *arg) {
|
|
struct mg_threadparam *tp = (struct mg_threadparam *) arg;
|
|
int k = 0, stop = 0;
|
|
DWORD n, sent;
|
|
char buf[BUFSIZ];
|
|
|
|
while (!stop && ReadFile(tp->hPipe, buf, sizeof(buf), &n, NULL)) {
|
|
for (sent = 0; !stop && sent < n; sent += k) {
|
|
if (mg_wait_until_ready(tp->s, 0) &&
|
|
(k = send(tp->s, buf + sent, n - sent, 0)) <= 0)
|
|
stop = 1;
|
|
}
|
|
}
|
|
DBG(("%s", "EOF FROM CGI"));
|
|
CloseHandle(tp->hPipe);
|
|
shutdown(tp->s, 2); // Without this, IO thread may get truncated data
|
|
closesocket(tp->s);
|
|
MG_FREE(tp);
|
|
return NULL;
|
|
}
|
|
|
|
static void mg_spawn_stdio_thread(sock_t sock, HANDLE hPipe,
|
|
void *(*func)(void *)) {
|
|
struct mg_threadparam *tp = (struct mg_threadparam *) MG_MALLOC(sizeof(*tp));
|
|
if (tp != NULL) {
|
|
tp->s = sock;
|
|
tp->hPipe = hPipe;
|
|
mg_start_thread(func, tp);
|
|
}
|
|
}
|
|
|
|
static void mg_abs_path(const char *utf8_path, char *abs_path, size_t len) {
|
|
wchar_t buf[MG_MAX_PATH], buf2[MG_MAX_PATH];
|
|
to_wchar(utf8_path, buf, ARRAY_SIZE(buf));
|
|
GetFullPathNameW(buf, ARRAY_SIZE(buf2), buf2, NULL);
|
|
WideCharToMultiByte(CP_UTF8, 0, buf2, wcslen(buf2) + 1, abs_path, len, 0, 0);
|
|
}
|
|
|
|
static int mg_start_process(const char *interp, const char *cmd,
|
|
const char *env, const char *envp[],
|
|
const char *dir, sock_t sock) {
|
|
STARTUPINFOW si;
|
|
PROCESS_INFORMATION pi;
|
|
HANDLE a[2], b[2], me = GetCurrentProcess();
|
|
wchar_t wcmd[MG_MAX_PATH], full_dir[MG_MAX_PATH];
|
|
char buf[MG_MAX_PATH], buf2[MG_MAX_PATH], buf5[MG_MAX_PATH],
|
|
buf4[MG_MAX_PATH], cmdline[MG_MAX_PATH];
|
|
DWORD flags = DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS;
|
|
FILE *fp;
|
|
|
|
memset(&si, 0, sizeof(si));
|
|
memset(&pi, 0, sizeof(pi));
|
|
|
|
si.cb = sizeof(si);
|
|
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
|
|
si.wShowWindow = SW_HIDE;
|
|
si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
|
|
|
|
CreatePipe(&a[0], &a[1], NULL, 0);
|
|
CreatePipe(&b[0], &b[1], NULL, 0);
|
|
DuplicateHandle(me, a[0], me, &si.hStdInput, 0, TRUE, flags);
|
|
DuplicateHandle(me, b[1], me, &si.hStdOutput, 0, TRUE, flags);
|
|
|
|
if (interp == NULL && (fp = mg_fopen(cmd, "r")) != NULL) {
|
|
buf[0] = buf[1] = '\0';
|
|
fgets(buf, sizeof(buf), fp);
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
if (buf[0] == '#' && buf[1] == '!') {
|
|
interp = buf + 2;
|
|
/* Trim leading spaces: https://github.com/cesanta/mongoose/issues/489 */
|
|
while (*interp != '\0' && isspace(*(unsigned char *) interp)) {
|
|
interp++;
|
|
}
|
|
}
|
|
fclose(fp);
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "%s/%s", dir, cmd);
|
|
mg_abs_path(buf, buf2, ARRAY_SIZE(buf2));
|
|
|
|
mg_abs_path(dir, buf5, ARRAY_SIZE(buf5));
|
|
to_wchar(dir, full_dir, ARRAY_SIZE(full_dir));
|
|
|
|
if (interp != NULL) {
|
|
mg_abs_path(interp, buf4, ARRAY_SIZE(buf4));
|
|
snprintf(cmdline, sizeof(cmdline), "%s \"%s\"", buf4, buf2);
|
|
} else {
|
|
snprintf(cmdline, sizeof(cmdline), "\"%s\"", buf2);
|
|
}
|
|
to_wchar(cmdline, wcmd, ARRAY_SIZE(wcmd));
|
|
|
|
if (CreateProcessW(NULL, wcmd, NULL, NULL, TRUE, CREATE_NEW_PROCESS_GROUP,
|
|
(void *) env, full_dir, &si, &pi) != 0) {
|
|
mg_spawn_stdio_thread(sock, a[1], mg_push_to_stdin);
|
|
mg_spawn_stdio_thread(sock, b[0], mg_pull_from_stdout);
|
|
|
|
CloseHandle(si.hStdOutput);
|
|
CloseHandle(si.hStdInput);
|
|
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
} else {
|
|
CloseHandle(a[1]);
|
|
CloseHandle(b[0]);
|
|
closesocket(sock);
|
|
}
|
|
DBG(("CGI command: [%ls] -> %p", wcmd, pi.hProcess));
|
|
|
|
/* Not closing a[0] and b[1] because we've used DUPLICATE_CLOSE_SOURCE */
|
|
(void) envp;
|
|
return (pi.hProcess != NULL);
|
|
}
|
|
#else
|
|
static int mg_start_process(const char *interp, const char *cmd,
|
|
const char *env, const char *envp[],
|
|
const char *dir, sock_t sock) {
|
|
char buf[500];
|
|
pid_t pid = fork();
|
|
(void) env;
|
|
|
|
if (pid == 0) {
|
|
/*
|
|
* In Linux `chdir` declared with `warn_unused_result` attribute
|
|
* To shutup compiler we have yo use result in some way
|
|
*/
|
|
int tmp = chdir(dir);
|
|
(void) tmp;
|
|
(void) dup2(sock, 0);
|
|
(void) dup2(sock, 1);
|
|
closesocket(sock);
|
|
|
|
/*
|
|
* After exec, all signal handlers are restored to their default values,
|
|
* with one exception of SIGCHLD. According to POSIX.1-2001 and Linux's
|
|
* implementation, SIGCHLD's handler will leave unchanged after exec
|
|
* if it was set to be ignored. Restore it to default action.
|
|
*/
|
|
signal(SIGCHLD, SIG_DFL);
|
|
|
|
if (interp == NULL) {
|
|
execle(cmd, cmd, (char *) 0, envp); /* (char *) 0 to squash warning */
|
|
} else {
|
|
execle(interp, interp, cmd, (char *) 0, envp);
|
|
}
|
|
snprintf(buf, sizeof(buf),
|
|
"Status: 500\r\n\r\n"
|
|
"500 Server Error: %s%s%s: %s",
|
|
interp == NULL ? "" : interp, interp == NULL ? "" : " ", cmd,
|
|
strerror(errno));
|
|
send(1, buf, strlen(buf), 0);
|
|
_exit(EXIT_FAILURE); /* exec call failed */
|
|
}
|
|
|
|
return (pid != 0);
|
|
}
|
|
#endif /* _WIN32 */
|
|
|
|
/*
|
|
* Append VARIABLE=VALUE\0 string to the buffer, and add a respective
|
|
* pointer into the vars array.
|
|
*/
|
|
static char *mg_addenv(struct mg_cgi_env_block *block, const char *fmt, ...) {
|
|
int n, space;
|
|
char *added = block->buf + block->len;
|
|
va_list ap;
|
|
|
|
/* Calculate how much space is left in the buffer */
|
|
space = sizeof(block->buf) - (block->len + 2);
|
|
if (space > 0) {
|
|
/* Copy VARIABLE=VALUE\0 string into the free space */
|
|
va_start(ap, fmt);
|
|
n = vsnprintf(added, (size_t) space, fmt, ap);
|
|
va_end(ap);
|
|
|
|
/* Make sure we do not overflow buffer and the envp array */
|
|
if (n > 0 && n + 1 < space &&
|
|
block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
|
|
/* Append a pointer to the added string into the envp array */
|
|
block->vars[block->nvars++] = added;
|
|
/* Bump up used length counter. Include \0 terminator */
|
|
block->len += n + 1;
|
|
}
|
|
}
|
|
|
|
return added;
|
|
}
|
|
|
|
static void mg_addenv2(struct mg_cgi_env_block *blk, const char *name) {
|
|
const char *s;
|
|
if ((s = getenv(name)) != NULL) mg_addenv(blk, "%s=%s", name, s);
|
|
}
|
|
|
|
static void mg_prepare_cgi_environment(struct mg_connection *nc,
|
|
const char *prog,
|
|
const struct mg_str *path_info,
|
|
const struct http_message *hm,
|
|
const struct mg_serve_http_opts *opts,
|
|
struct mg_cgi_env_block *blk) {
|
|
const char *s;
|
|
struct mg_str *h;
|
|
char *p;
|
|
size_t i;
|
|
char buf[100];
|
|
size_t path_info_len = path_info != NULL ? path_info->len : 0;
|
|
|
|
blk->len = blk->nvars = 0;
|
|
blk->nc = nc;
|
|
|
|
if ((s = getenv("SERVER_NAME")) != NULL) {
|
|
mg_addenv(blk, "SERVER_NAME=%s", s);
|
|
} else {
|
|
mg_sock_to_str(nc->sock, buf, sizeof(buf), 3);
|
|
mg_addenv(blk, "SERVER_NAME=%s", buf);
|
|
}
|
|
mg_addenv(blk, "SERVER_ROOT=%s", opts->document_root);
|
|
mg_addenv(blk, "DOCUMENT_ROOT=%s", opts->document_root);
|
|
mg_addenv(blk, "SERVER_SOFTWARE=%s/%s", "Mongoose", MG_VERSION);
|
|
|
|
/* Prepare the environment block */
|
|
mg_addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1");
|
|
mg_addenv(blk, "%s", "SERVER_PROTOCOL=HTTP/1.1");
|
|
mg_addenv(blk, "%s", "REDIRECT_STATUS=200"); /* For PHP */
|
|
|
|
mg_addenv(blk, "REQUEST_METHOD=%.*s", (int) hm->method.len, hm->method.p);
|
|
|
|
mg_addenv(blk, "REQUEST_URI=%.*s%s%.*s", (int) hm->uri.len, hm->uri.p,
|
|
hm->query_string.len == 0 ? "" : "?", (int) hm->query_string.len,
|
|
hm->query_string.p);
|
|
|
|
mg_conn_addr_to_str(nc, buf, sizeof(buf),
|
|
MG_SOCK_STRINGIFY_REMOTE | MG_SOCK_STRINGIFY_IP);
|
|
mg_addenv(blk, "REMOTE_ADDR=%s", buf);
|
|
mg_conn_addr_to_str(nc, buf, sizeof(buf), MG_SOCK_STRINGIFY_PORT);
|
|
mg_addenv(blk, "SERVER_PORT=%s", buf);
|
|
|
|
s = hm->uri.p + hm->uri.len - path_info_len - 1;
|
|
if (*s == '/') {
|
|
const char *base_name = strrchr(prog, DIRSEP);
|
|
mg_addenv(blk, "SCRIPT_NAME=%.*s/%s", (int) (s - hm->uri.p), hm->uri.p,
|
|
(base_name != NULL ? base_name + 1 : prog));
|
|
} else {
|
|
mg_addenv(blk, "SCRIPT_NAME=%.*s", (int) (s - hm->uri.p + 1), hm->uri.p);
|
|
}
|
|
mg_addenv(blk, "SCRIPT_FILENAME=%s", prog);
|
|
|
|
if (path_info != NULL && path_info->len > 0) {
|
|
mg_addenv(blk, "PATH_INFO=%.*s", (int) path_info->len, path_info->p);
|
|
/* Not really translated... */
|
|
mg_addenv(blk, "PATH_TRANSLATED=%.*s", (int) path_info->len, path_info->p);
|
|
}
|
|
|
|
#if MG_ENABLE_SSL
|
|
mg_addenv(blk, "HTTPS=%s", (nc->flags & MG_F_SSL ? "on" : "off"));
|
|
#else
|
|
mg_addenv(blk, "HTTPS=off");
|
|
#endif
|
|
|
|
if ((h = mg_get_http_header((struct http_message *) hm, "Content-Type")) !=
|
|
NULL) {
|
|
mg_addenv(blk, "CONTENT_TYPE=%.*s", (int) h->len, h->p);
|
|
}
|
|
|
|
if (hm->query_string.len > 0) {
|
|
mg_addenv(blk, "QUERY_STRING=%.*s", (int) hm->query_string.len,
|
|
hm->query_string.p);
|
|
}
|
|
|
|
if ((h = mg_get_http_header((struct http_message *) hm, "Content-Length")) !=
|
|
NULL) {
|
|
mg_addenv(blk, "CONTENT_LENGTH=%.*s", (int) h->len, h->p);
|
|
}
|
|
|
|
mg_addenv2(blk, "PATH");
|
|
mg_addenv2(blk, "TMP");
|
|
mg_addenv2(blk, "TEMP");
|
|
mg_addenv2(blk, "TMPDIR");
|
|
mg_addenv2(blk, "PERLLIB");
|
|
mg_addenv2(blk, MG_ENV_EXPORT_TO_CGI);
|
|
|
|
#ifdef _WIN32
|
|
mg_addenv2(blk, "COMSPEC");
|
|
mg_addenv2(blk, "SYSTEMROOT");
|
|
mg_addenv2(blk, "SystemDrive");
|
|
mg_addenv2(blk, "ProgramFiles");
|
|
mg_addenv2(blk, "ProgramFiles(x86)");
|
|
mg_addenv2(blk, "CommonProgramFiles(x86)");
|
|
#else
|
|
mg_addenv2(blk, "LD_LIBRARY_PATH");
|
|
#endif /* _WIN32 */
|
|
|
|
/* Add all headers as HTTP_* variables */
|
|
for (i = 0; hm->header_names[i].len > 0; i++) {
|
|
p = mg_addenv(blk, "HTTP_%.*s=%.*s", (int) hm->header_names[i].len,
|
|
hm->header_names[i].p, (int) hm->header_values[i].len,
|
|
hm->header_values[i].p);
|
|
|
|
/* Convert variable name into uppercase, and change - to _ */
|
|
for (; *p != '=' && *p != '\0'; p++) {
|
|
if (*p == '-') *p = '_';
|
|
*p = (char) toupper(*(unsigned char *) p);
|
|
}
|
|
}
|
|
|
|
blk->vars[blk->nvars++] = NULL;
|
|
blk->buf[blk->len++] = '\0';
|
|
}
|
|
|
|
static void mg_cgi_ev_handler(struct mg_connection *cgi_nc, int ev,
|
|
void *ev_data MG_UD_ARG(void *user_data)) {
|
|
#if !MG_ENABLE_CALLBACK_USERDATA
|
|
void *user_data = cgi_nc->user_data;
|
|
#endif
|
|
struct mg_connection *nc = (struct mg_connection *) user_data;
|
|
(void) ev_data;
|
|
|
|
if (nc == NULL) {
|
|
/* The corresponding network connection was closed. */
|
|
cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
|
|
return;
|
|
}
|
|
|
|
switch (ev) {
|
|
case MG_EV_RECV:
|
|
/*
|
|
* CGI script does not output reply line, like "HTTP/1.1 CODE XXXXX\n"
|
|
* It outputs headers, then body. Headers might include "Status"
|
|
* header, which changes CODE, and it might include "Location" header
|
|
* which changes CODE to 302.
|
|
*
|
|
* Therefore we do not send the output from the CGI script to the user
|
|
* until all CGI headers are received.
|
|
*
|
|
* Here we parse the output from the CGI script, and if all headers has
|
|
* been received, send appropriate reply line, and forward all
|
|
* received headers to the client.
|
|
*/
|
|
if (nc->flags & MG_F_HTTP_CGI_PARSE_HEADERS) {
|
|
struct mbuf *io = &cgi_nc->recv_mbuf;
|
|
int len = mg_http_get_request_len(io->buf, io->len);
|
|
|
|
if (len == 0) break;
|
|
if (len < 0 || io->len > MG_MAX_HTTP_REQUEST_SIZE) {
|
|
cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
|
|
mg_http_send_error(nc, 500, "Bad headers");
|
|
} else {
|
|
struct http_message hm;
|
|
struct mg_str *h;
|
|
mg_http_parse_headers(io->buf, io->buf + io->len, io->len, &hm);
|
|
if (mg_get_http_header(&hm, "Location") != NULL) {
|
|
mg_printf(nc, "%s", "HTTP/1.1 302 Moved\r\n");
|
|
} else if ((h = mg_get_http_header(&hm, "Status")) != NULL) {
|
|
mg_printf(nc, "HTTP/1.1 %.*s\r\n", (int) h->len, h->p);
|
|
} else {
|
|
mg_printf(nc, "%s", "HTTP/1.1 200 OK\r\n");
|
|
}
|
|
}
|
|
nc->flags &= ~MG_F_HTTP_CGI_PARSE_HEADERS;
|
|
}
|
|
if (!(nc->flags & MG_F_HTTP_CGI_PARSE_HEADERS)) {
|
|
mg_forward(cgi_nc, nc);
|
|
}
|
|
break;
|
|
case MG_EV_CLOSE:
|
|
DBG(("%p CLOSE", cgi_nc));
|
|
mg_http_free_proto_data_cgi(&mg_http_get_proto_data(nc)->cgi);
|
|
nc->flags |= MG_F_SEND_AND_CLOSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
MG_INTERNAL void mg_handle_cgi(struct mg_connection *nc, const char *prog,
|
|
const struct mg_str *path_info,
|
|
const struct http_message *hm,
|
|
const struct mg_serve_http_opts *opts) {
|
|
struct mg_cgi_env_block blk;
|
|
char dir[MG_MAX_PATH];
|
|
const char *p;
|
|
sock_t fds[2];
|
|
|
|
DBG(("%p [%s]", nc, prog));
|
|
mg_prepare_cgi_environment(nc, prog, path_info, hm, opts, &blk);
|
|
/*
|
|
* CGI must be executed in its own directory. 'dir' must point to the
|
|
* directory containing executable program, 'p' must point to the
|
|
* executable program name relative to 'dir'.
|
|
*/
|
|
if ((p = strrchr(prog, DIRSEP)) == NULL) {
|
|
snprintf(dir, sizeof(dir), "%s", ".");
|
|
} else {
|
|
snprintf(dir, sizeof(dir), "%.*s", (int) (p - prog), prog);
|
|
prog = p + 1;
|
|
}
|
|
|
|
if (!mg_socketpair(fds, SOCK_STREAM)) {
|
|
nc->flags |= MG_F_CLOSE_IMMEDIATELY;
|
|
return;
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
struct sigaction sa;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_handler = SIG_IGN;
|
|
sa.sa_flags = 0;
|
|
sigaction(SIGCHLD, &sa, NULL);
|
|
#endif
|
|
|
|
if (mg_start_process(opts->cgi_interpreter, prog, blk.buf, blk.vars, dir,
|
|
fds[1]) != 0) {
|
|
struct mg_connection *cgi_nc =
|
|
mg_add_sock(nc->mgr, fds[0], mg_cgi_ev_handler MG_UD_ARG(nc));
|
|
struct mg_http_proto_data *cgi_pd = mg_http_get_proto_data(nc);
|
|
cgi_pd->cgi.cgi_nc = cgi_nc;
|
|
#if !MG_ENABLE_CALLBACK_USERDATA
|
|
cgi_pd->cgi.cgi_nc->user_data = nc;
|
|
#endif
|
|
nc->flags |= MG_F_HTTP_CGI_PARSE_HEADERS;
|
|
/* Push POST data to the CGI */
|
|
if (hm->body.len > 0) {
|
|
mg_send(cgi_pd->cgi.cgi_nc, hm->body.p, hm->body.len);
|
|
}
|
|
mbuf_remove(&nc->recv_mbuf, nc->recv_mbuf.len);
|
|
} else {
|
|
closesocket(fds[0]);
|
|
mg_http_send_error(nc, 500, "CGI failure");
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
closesocket(fds[1]); /* On Windows, CGI stdio thread closes that socket */
|
|
#endif
|
|
}
|
|
|
|
MG_INTERNAL void mg_http_free_proto_data_cgi(struct mg_http_proto_data_cgi *d) {
|
|
if (d == NULL) return;
|
|
if (d->cgi_nc != NULL) {
|
|
d->cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY;
|
|
d->cgi_nc->user_data = NULL;
|
|
}
|
|
memset(d, 0, sizeof(*d));
|
|
}
|
|
|
|
#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI */
|