version 0.2.15
[fms.git] / libs / shttpd / compat_win32.c
1 /*
2  * Copyright (c) 2004-2005 Sergey Lyubka <valenok@gmail.com>
3  * All rights reserved
4  *
5  * "THE BEER-WARE LICENSE" (Revision 42):
6  * Sergey Lyubka wrote this file.  As long as you retain this notice you
7  * can do whatever you want with this stuff. If we meet some day, and you think
8  * this stuff is worth it, you can buy me a beer in return.
9  */
10
11 #include "defs.h"
12
13 static void
14 fix_directory_separators(char *path)
15 {
16         for (; *path != '\0'; path++) {
17                 if (*path == '/')
18                         *path = '\\';
19                 if (*path == '\\')
20                         while (path[1] == '\\' || path[1] == '/') 
21                                 (void) memmove(path + 1,
22                                     path + 2, strlen(path + 2) + 1);
23         }
24 }
25
26 static int
27 protect_against_code_disclosure(const char *path)
28 {
29         WIN32_FIND_DATA data;
30         HANDLE          handle;
31         const char      *p;
32
33         /*
34          * Protect against CGI code disclosure under Windows.
35          * This is very nasty hole. Windows happily opens files with
36          * some garbage in the end of file name. So fopen("a.cgi    ", "r")
37          * actually opens "a.cgi", and does not return an error! And since
38          * "a.cgi    " does not have valid CGI extension, this leads to
39          * the CGI code disclosure.
40          * To protect, here we delete all fishy characters from the
41          * end of file name.
42          */
43
44         if ((handle = FindFirstFile(path, &data)) == INVALID_HANDLE_VALUE)
45                 return (FALSE);
46
47         FindClose(handle);
48
49         for (p = path + strlen(path); p > path && p[-1] != '\\';)
50                 p--;
51         
52         if (!(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
53             strcmp(data.cFileName, p) != 0)
54                 return (FALSE);
55
56         return (TRUE);
57 }
58
59 int
60 my_open(const char *path, int flags, int mode)
61 {
62         char    buf[FILENAME_MAX];
63         wchar_t wbuf[FILENAME_MAX];
64
65         my_strlcpy(buf, path, sizeof(buf));
66         fix_directory_separators(buf);
67         MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
68
69         if (protect_against_code_disclosure(buf) == FALSE)
70                 return (-1);
71
72         return (_wopen(wbuf, flags));
73 }
74
75 int
76 my_stat(const char *path, struct stat *stp)
77 {
78         char    buf[FILENAME_MAX], *p;
79         wchar_t wbuf[FILENAME_MAX];
80
81         my_strlcpy(buf, path, sizeof(buf));
82         fix_directory_separators(buf);
83
84         p = buf + strlen(buf) - 1;
85         while (p > buf && *p == '\\' && p[-1] != ':')
86                 *p-- = '\0';
87
88         MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
89
90         return (_wstat(wbuf, (struct _stat *) stp));
91 }
92
93 int
94 my_remove(const char *path)
95 {
96         char    buf[FILENAME_MAX];
97         wchar_t wbuf[FILENAME_MAX];
98
99         my_strlcpy(buf, path, sizeof(buf));
100         fix_directory_separators(buf);
101
102         MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
103
104         return (_wremove(wbuf));
105 }
106
107 int
108 my_rename(const char *path1, const char *path2)
109 {
110         char    buf1[FILENAME_MAX];
111         char    buf2[FILENAME_MAX];
112         wchar_t wbuf1[FILENAME_MAX];
113         wchar_t wbuf2[FILENAME_MAX];
114
115         my_strlcpy(buf1, path1, sizeof(buf1));
116         my_strlcpy(buf2, path2, sizeof(buf2));
117         fix_directory_separators(buf1);
118         fix_directory_separators(buf2);
119
120         MultiByteToWideChar(CP_UTF8, 0, buf1, -1, wbuf1, sizeof(wbuf1));
121         MultiByteToWideChar(CP_UTF8, 0, buf2, -1, wbuf2, sizeof(wbuf2));
122
123         return (_wrename(wbuf1, wbuf2));
124 }
125
126 int
127 my_mkdir(const char *path, int mode)
128 {
129         char    buf[FILENAME_MAX];
130         wchar_t wbuf[FILENAME_MAX];
131
132         my_strlcpy(buf, path, sizeof(buf));
133         fix_directory_separators(buf);
134
135         MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
136
137         return (_wmkdir(wbuf));
138 }
139
140 static char *
141 wide_to_utf8(const wchar_t *str)
142 {
143         char *buf = NULL;
144         if (str) {
145                 int nchar = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
146                 if (nchar > 0) {
147                         buf = malloc(nchar);
148                         if (!buf)
149                                 errno = ENOMEM;
150                         else if (!WideCharToMultiByte(CP_UTF8, 0, str, -1, buf, nchar, NULL, NULL)) {
151                                 free(buf);
152                                 buf = NULL;
153                                 errno = EINVAL;
154                         }
155                 } else
156                         errno = EINVAL;
157         } else
158                 errno = EINVAL;
159         return buf;
160 }
161
162 char *
163 my_getcwd(char *buffer, int maxlen)
164 {
165         char *result = NULL;
166         wchar_t *wbuffer, *wresult;
167
168         if (buffer) {
169                 /* User-supplied buffer */
170                 wbuffer = malloc(maxlen * sizeof(wchar_t));
171                 if (wbuffer == NULL)
172                         return NULL;
173         } else
174                 /* Dynamically allocated buffer */
175                 wbuffer = NULL;
176         wresult = _wgetcwd(wbuffer, maxlen);
177         if (wresult) {
178                 int err = errno;
179                 if (buffer) {
180                         /* User-supplied buffer */
181                         int n = WideCharToMultiByte(CP_UTF8, 0, wresult, -1, buffer, maxlen, NULL, NULL);
182                         if (n == 0)
183                                 err = ERANGE;
184                         free(wbuffer);
185                         result = buffer;
186                 } else {
187                         /* Buffer allocated by _wgetcwd() */
188                         result = wide_to_utf8(wresult);
189                         err = errno;
190                         free(wresult);
191                 }
192                 errno = err;
193         }
194         return result;
195 }
196
197 DIR *
198 opendir(const char *name)
199 {
200         DIR             *dir = NULL;
201         char            path[FILENAME_MAX];
202         wchar_t         wpath[FILENAME_MAX];
203
204         if (name == NULL || name[0] == '\0') {
205                 errno = EINVAL;
206         } else if ((dir = malloc(sizeof(*dir))) == NULL) {
207                 errno = ENOMEM;
208         } else {
209                 my_snprintf(path, sizeof(path), "%s/*", name);
210                 fix_directory_separators(path);
211                 MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, sizeof(wpath));
212                 dir->handle = FindFirstFileW(wpath, &dir->info);
213
214                 if (dir->handle != INVALID_HANDLE_VALUE) {
215                         dir->result.d_name[0] = '\0';
216                 } else {
217                         free(dir);
218                         dir = NULL;
219                 }
220         }
221
222         return (dir);
223 }
224
225 int
226 closedir(DIR *dir)
227 {
228         int result = -1;
229
230         if (dir != NULL) {
231                 if (dir->handle != INVALID_HANDLE_VALUE)
232                         result = FindClose(dir->handle) ? 0 : -1;
233
234                 free(dir);
235         }
236
237         if (result == -1) 
238                 errno = EBADF;
239
240         return (result);
241 }
242
243 struct dirent *
244 readdir(DIR *dir)
245 {
246         struct dirent *result = 0;
247
248         if (dir && dir->handle != INVALID_HANDLE_VALUE) {
249                 if(!dir->result.d_name ||
250                     FindNextFileW(dir->handle, &dir->info)) {
251                         result = &dir->result;
252
253                         WideCharToMultiByte(CP_UTF8, 0, dir->info.cFileName,
254                             -1, result->d_name,
255                             sizeof(result->d_name), NULL, NULL);
256                 }
257         } else {
258                 errno = EBADF;
259         }
260
261         return (result);
262 }
263
264 int
265 set_non_blocking_mode(int fd)
266 {
267         unsigned long   on = 1;
268
269         return (ioctlsocket(fd, FIONBIO, &on));
270 }
271
272 void
273 set_close_on_exec(int fd)
274 {
275         fd = 0; /* Do nothing. There is no FD_CLOEXEC on Windows */
276 }
277
278 #if !defined(NO_CGI)
279
280 struct threadparam {
281         SOCKET  s;
282         HANDLE  hPipe;
283         big_int_t content_len;
284 };
285
286 /*
287  * Thread function that reads POST data from the socket pair
288  * and writes it to the CGI process.
289  */
290 static void//DWORD WINAPI
291 stdoutput(void *arg)
292 {
293         struct threadparam      *tp = arg;
294         int                     n, sent, stop = 0;
295         big_int_t               total = 0;
296         DWORD k;
297         char                    buf[BUFSIZ];
298         size_t                  max_recv;
299
300         max_recv = min(sizeof(buf), tp->content_len - total);
301         while (!stop && max_recv > 0 && (n = recv(tp->s, buf, max_recv, 0)) > 0) {
302                 for (sent = 0; !stop && sent < n; sent += k)
303                         if (!WriteFile(tp->hPipe, buf + sent, n - sent, &k, 0))
304                                 stop++;
305                 total += n;
306                 max_recv = min(sizeof(buf), tp->content_len - total);
307         }
308         
309         CloseHandle(tp->hPipe); /* Suppose we have POSTed everything */
310         free(tp);
311 }
312
313 /*
314  * Thread function that reads CGI output and pushes it to the socket pair.
315  */
316 static void
317 stdinput(void *arg)
318 {
319         struct threadparam      *tp = arg;
320         static                  int ntotal;
321         int                     k, stop = 0;
322         DWORD n, sent;
323         char                    buf[BUFSIZ];
324
325         while (!stop && ReadFile(tp->hPipe, buf, sizeof(buf), &n, NULL)) {
326                 ntotal += n;
327                 for (sent = 0; !stop && sent < n; sent += k)
328                         if ((k = send(tp->s, buf + sent, n - sent, 0)) <= 0)
329                                 stop++;
330         }
331         CloseHandle(tp->hPipe);
332         
333         /*
334          * Windows is a piece of crap. When this thread closes its end
335          * of the socket pair, the other end (get_cgi() function) may loose
336          * some data. I presume, this happens if get_cgi() is not fast enough,
337          * and the data written by this end does not "push-ed" to the other
338          * end socket buffer. So after closesocket() the remaining data is
339          * gone. If I put shutdown() before closesocket(), that seems to
340          * fix the problem, but I am not sure this is the right fix.
341          * XXX (submitted by James Marshall) we do not do shutdown() on UNIX.
342          * If fork() is called from user callback, shutdown() messes up things.
343          */
344         shutdown(tp->s, 2);
345
346         closesocket(tp->s);
347         free(tp);
348
349         _endthread();
350 }
351
352 static void
353 spawn_stdio_thread(int sock, HANDLE hPipe, void (*func)(void *),
354                 big_int_t content_len)
355 {
356         struct threadparam      *tp;
357         DWORD                   tid;
358
359         tp = malloc(sizeof(*tp));
360         assert(tp != NULL);
361
362         tp->s           = sock;
363         tp->hPipe       = hPipe;
364         tp->content_len = content_len;
365         _beginthread(func, 0, tp);
366 }
367
368 int
369 spawn_process(struct conn *c, const char *prog, char *envblk,
370                 char *envp[], int sock, const char *dir)
371 {
372         HANDLE                  a[2], b[2], h[2], me;
373         DWORD                   flags;
374         char                    *p, cmdline[FILENAME_MAX], line[FILENAME_MAX];
375         FILE                    *fp;
376         STARTUPINFOA    si;
377         PROCESS_INFORMATION     pi;
378
379         me = GetCurrentProcess();
380         flags = DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS;
381
382         /* FIXME add error checking code here */
383         CreatePipe(&a[0], &a[1], NULL, 0);
384         CreatePipe(&b[0], &b[1], NULL, 0);
385         DuplicateHandle(me, a[0], me, &h[0], 0, TRUE, flags);
386         DuplicateHandle(me, b[1], me, &h[1], 0, TRUE, flags);
387         
388         (void) memset(&si, 0, sizeof(si));
389         (void) memset(&pi, 0, sizeof(pi));
390
391         /* XXX redirect CGI errors to the error log file */
392         si.cb           = sizeof(si);
393         si.dwFlags      = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
394         si.wShowWindow  = SW_HIDE;
395         si.hStdOutput   = si.hStdError = h[1];
396         si.hStdInput    = h[0];
397
398         /* If CGI file is a script, try to read the interpreter line */
399         if (c->ctx->options[OPT_CGI_INTERPRETER] == NULL) {
400                 if ((fp = fopen(prog, "r")) != NULL) {
401                         (void) fgets(line, sizeof(line), fp);
402                         if (memcmp(line, "#!", 2) != 0)
403                                 line[2] = '\0';
404                         /* Trim whitespaces from interpreter name */
405                         for (p = &line[strlen(line) - 1]; p > line &&
406                             isspace(*p); p--)
407                                 *p = '\0';
408                         (void) fclose(fp);
409                 }
410                 (void) my_snprintf(cmdline, sizeof(cmdline), "%s%s%s",
411                     line + 2, line[2] == '\0' ? "" : " ", prog);
412         } else {
413                 (void) my_snprintf(cmdline, sizeof(cmdline), "%s %s",
414                     c->ctx->options[OPT_CGI_INTERPRETER], prog);
415         }
416
417         (void) my_snprintf(line, sizeof(line), "%s", dir);
418         fix_directory_separators(line);
419         fix_directory_separators(cmdline);
420
421         /*
422          * Spawn reader & writer threads before we create CGI process.
423          * Otherwise CGI process may die too quickly, loosing the data
424          */
425         spawn_stdio_thread(sock, b[0], stdinput, 0);
426         spawn_stdio_thread(sock, a[1], stdoutput, c->rem.content_len);
427
428         if (CreateProcessA(NULL, cmdline, NULL, NULL, TRUE,
429             CREATE_NEW_PROCESS_GROUP, envblk, line, &si, &pi) == 0) {
430                 elog(E_LOG, c,"redirect: CreateProcess(%s): %d",cmdline,ERRNO);
431                 return (-1);
432         } else {
433                 CloseHandle(h[0]);
434                 CloseHandle(h[1]);
435                 CloseHandle(pi.hThread);
436                 CloseHandle(pi.hProcess);
437         }
438
439         return (0);
440 }
441
442 #endif /* !NO_CGI */