WebSVN – Tewi – Diff – /trunk/Server/server.c

-/* $Id: server.c 189 2024-09-29 00:37:00Z nishi $ */
+/* $Id: server.c 212 2024-10-02 17:44:55Z nishi $ */
 #define SOURCE
 #include "../config.h"
 #include "tw_config.h"
 #include "tw_http.h"
 #include "tw_module.h"
 #include "tw_version.h"
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
 #include <string.h>
 #include <stdbool.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
-#include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <time.h>
 #include <cm_string.h>
 #include <cm_log.h>
 #include <cm_dir.h>
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
 #ifndef NO_GETADDRINFO
 #include <ws2tcpip.h>
 #include <wspiapi.h>
 #endif
 #include <winsock2.h>
 #ifdef __HAIKU__
 #include <OS.h>
 #endif
+#ifndef S_ISDIR
+#define S_ISDIR(x) ((x) & _S_IFDIR)
+#endif
 extern struct tw_config config;
 extern char tw_server[];
 int sockcount = 0;
 SOCKADDR addresses[MAX_PORTS];
 int sockets[MAX_PORTS];
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
 const char* reserved_names[] = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"};
 #endif
 /* https://qiita.com/gyu-don/items/5a640c6d2252a860c8cd */
 int tw_wildcard_match(const char* wildcard, const char* target) {
+		}
+	}
+}
 void close_socket(int sock) {
-#if defined(__MINGW32__)
+#if defined(__MINGW32__) || defined(_MSC_VER)
 	closesocket(sock);
 #else
 	close(sock);
 #endif
+}
 int tw_server_init(void) {
 	int i;
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
 	WSADATA wsa;
 	WSAStartup(MAKEWORD(2, 0), &wsa);
 #endif
 	for(i = 0; config.ports[i] != -1; i++)
+		;
 	sockcount = i;
 	for(i = 0; config.ports[i] != -1; i++) {
+		int yes = 1;
+		int no = 0;
 #ifdef NO_IPV6
 		int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 #else
 		int sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
 #endif
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
 		if(sock == INVALID_SOCKET)
 #else
 		if(sock < 0)
 #endif
+		{
 			cm_log("Server", "Socket creation failure");
 			return 1;
+		}
-		int yes = 1;
 		if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*)&yes, sizeof(yes)) < 0) {
 			close_socket(sock);
 			cm_log("Server", "setsockopt failure (reuseaddr)");
 			return 1;
+		}
 			cm_log("Server", "setsockopt failure (nodelay)");
 			return 1;
+		}
 #endif
 #ifndef NO_IPV6
-		int no = 0;
 		if(setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&no, sizeof(no)) < 0) {
 			close_socket(sock);
 			cm_log("Server", "setsockopt failure (IPv6)");
 			return 1;
+		}
 	    "	</body>\n" \
 	    "</html>\n"
 void _tw_process_page(SSL* ssl, int sock, const char* status, const char* type, FILE* f, const unsigned char* doc, size_t size, char** headers, time_t mtime, time_t cmtime) {
 	char construct[512];
+	size_t incr;
 	if(mtime != 0 && cmtime != 0 && mtime <= cmtime) {
 		status = "304 Not Modified";
 		type = NULL;
 		size = 0;
 		headers = NULL;
 		f = NULL;
 		doc = NULL;
+	}
+#ifdef _MSC_VER
+	sprintf(construct, "%lu", (unsigned long)size);
+#else
 	sprintf(construct, "%llu", (unsigned long long)size);
+#endif
 	tw_write(ssl, sock, "HTTP/1.1 ", 9);
 	tw_write(ssl, sock, (char*)status, strlen(status));
 	tw_write(ssl, sock, "\r\n", 2);
 	if(type != NULL) {
 		tw_write(ssl, sock, "Content-Type: ", 7 + 5 + 2);
 			tw_write(ssl, sock, "Last-Modified: ", 5 + 8 + 2);
 			tw_write(ssl, sock, date, strlen(date));
 			tw_write(ssl, sock, "\r\n", 2);
+		}
+	}
-	int i;
 	if(headers != NULL) {
+		int i;
 		for(i = 0; headers[i] != NULL; i += 2) {
 			tw_write(ssl, sock, headers[i], strlen(headers[i]));
 			tw_write(ssl, sock, ": ", 2);
 			tw_write(ssl, sock, headers[i + 1], strlen(headers[i + 1]));
 			tw_write(ssl, sock, "\r\n", 2);
+		}
+	}
 	tw_write(ssl, sock, "\r\n", 2);
 	if(doc == NULL && f == NULL) return;
-	size_t incr = 0;
+	incr = 0;
 	while(1) {
 		if(f != NULL) {
 			char buffer[128];
 			fread(buffer, size < 128 ? size : 128, 1, f);
 			tw_write(ssl, sock, buffer, size < 128 ? size : 128);
+	}
+}
 char* tw_http_default_error(int code, char* name, int port, struct tw_config_entry* vhost) {
 	char address[1024];
+	char* st;
+	char* st2;
+	char* buffer;
+	char* str;
+	int i;
 	if((vhost->hideport == -1 ? config.root.hideport : vhost->hideport) == 1) {
 		sprintf(address, "<address>%s Server at %s</address>", tw_server, name, port);
 	} else {
 		sprintf(address, "<address>%s Server at %s Port %d</address>", tw_server, name, port);
+	}
-	char* st = cm_strdup(tw_http_status(code));
+	st = cm_strdup(tw_http_status(code));
-	char* st2;
-	int i;
 	for(i = 0; st[i] != 0; i++) {
 		if(st[i] == ' ') {
 			st2 = cm_strdup(st + i + 1);
 			break;
+		}
+	}
-	char* buffer = malloc(4096);
+	buffer = malloc(4096);
-	char* str = cm_strcat3(ERROR_HTML);
+	str = cm_strcat3(ERROR_HTML);
 	sprintf(buffer, str, st, st2);
 	free(str);
 	free(st);
 	return buffer;
+}
+}
 void addstring(char** str, const char* add, ...) {
 	int i;
 	char cbuf[2];
-	cbuf[1] = 0;
 	va_list va;
+	cbuf[1] = 0;
 	va_start(va, add);
 	for(i = 0; add[i] != 0; i++) {
 		cbuf[0] = add[i];
 		if(add[i] == '%') {
 			i++;
 				free(tmp);
 				free(h);
 			} else if(add[i] == 'd') {
 				int n = va_arg(va, int);
 				char* h = malloc(512);
-				sprintf(h, "%d", n);
 				char* tmp = *str;
+				sprintf(h, "%d", n);
 				*str = cm_strcat(tmp, h);
 				free(tmp);
 				free(h);
 			} else if(add[i] == '%') {
 				char* tmp = *str;
 	va_end(va);
+}
 char* tw_get_mime(const char* ext, struct tw_config_entry* vhost_entry) {
 	char* mime = "application/octet-stream";
-	if(ext == NULL) return mime;
 	bool set = false;
 	int i;
+	if(ext == NULL) return mime;
 	for(i = 0; i < vhost_entry->mime_count; i++) {
 		if(strcmp(vhost_entry->mimes[i].ext, "all") == 0 || (ext != NULL && tw_wildcard_match(vhost_entry->mimes[i].ext, ext))) {
 			mime = vhost_entry->mimes[i].mime;
 			set = true;
+		}
 	return mime;
+}
 char* tw_get_icon(const char* mime, struct tw_config_entry* vhost_entry) {
 	char* icon = "";
-	if(mime == NULL) return "";
 	bool set = false;
 	int i;
+	if(mime == NULL) return "";
 	for(i = 0; i < vhost_entry->icon_count; i++) {
 		if(strcmp(vhost_entry->icons[i].mime, "all") == 0 || (mime != NULL && tw_wildcard_match(vhost_entry->icons[i].mime, mime))) {
 			icon = vhost_entry->icons[i].icon;
 			set = true;
+		}
 	int port;
 	bool ssl;
 	SOCKADDR addr;
 };
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
 unsigned int WINAPI tw_server_pass(void* ptr) {
 #elif defined(__HAIKU__)
 int32_t tw_server_pass(void* ptr) {
 #elif defined(_PSP) || defined(__PPU__)
 int tw_server_pass(void* ptr) {
 #endif
-#if defined(__HAIKU__) || defined(__MINGW32__) || defined(_PSP) || defined(__PPU__)
+#if defined(__HAIKU__) || defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(_MSC_VER)
+#define FREE_PTR
 	int sock = ((struct pass_entry*)ptr)->sock;
 	bool ssl = ((struct pass_entry*)ptr)->ssl;
 	int port = ((struct pass_entry*)ptr)->port;
 	SOCKADDR addr = ((struct pass_entry*)ptr)->addr;
-	free(ptr);
 #else
 	void tw_server_pass(int sock, bool ssl, int port, SOCKADDR addr) {
 #endif
-	char* name = config.hostname;
+	SSL* s = NULL;
 #ifndef NO_SSL
 	SSL_CTX* ctx = NULL;
-	SSL* s = NULL;
 	bool sslworks = false;
 	if(ssl) {
 		ctx = tw_create_ssl_ctx(port);
 		s = SSL_new(ctx);
 		SSL_set_fd(s, sock);
 		if(SSL_accept(s) <= 0) goto cleanup;
 		sslworks = true;
+	}
-#else
-		void* s = NULL;
 #endif
+	char* name = config.hostname;
 	char address[513];
-	address[0] = 0;
+	int ret;
+	struct tw_http_request req;
+	struct tw_http_response res;
+	struct tw_tool tools;
 #ifndef NO_GETADDRINFO
 	struct sockaddr* sa = (struct sockaddr*)&addr;
 	getnameinfo(sa, sizeof(addr), address, 512, NULL, 0, NI_NUMERICHOST);
 #endif
+	address[0] = 0;
+#ifdef FREE_PTR
+	free(ptr);
+#endif
-	struct tw_http_request req;
-	struct tw_http_response res;
-	struct tw_tool tools;
 	res._processed = false;
 	tw_init_tools(&tools);
-	int ret = tw_http_parse(s, sock, &req);
+	ret = tw_http_parse(s, sock, &req);
 	if(ret == 0) {
 		char date[513];
 		time_t t = time(NULL);
 		struct tm* tm = localtime(&t);
-		strftime(date, 512, "%a, %d %b %Y %H:%M:%S %Z", tm);
 		char* useragent = cm_strdup("");
 		int i;
+		char* tmp;
+		char* tmp2;
+		char* tmp3;
+		char* tmp4;
+		char* tmp5;
+		char* log;
+		char* vhost;
+		time_t cmtime;
+		bool rej;
+		char* host;
+		int port;
+		struct tw_config_entry* vhost_entry;
+		strftime(date, 512, "%a, %d %b %Y %H:%M:%S %Z", tm);
 		for(i = 0; req.headers[i] != NULL; i += 2) {
 			if(cm_strcaseequ(req.headers[i], "User-Agent")) {
 				free(useragent);
 				useragent = cm_strdup(req.headers[i + 1]);
+			}
+		}
-		char* tmp = cm_strcat3(address, " - [", date);
+		tmp = cm_strcat3(address, " - [", date);
-		char* tmp2 = cm_strcat3(tmp, "] \"", req.method);
+		tmp2 = cm_strcat3(tmp, "] \"", req.method);
-		char* tmp3 = cm_strcat3(tmp2, " ", req.path);
+		tmp3 = cm_strcat3(tmp2, " ", req.path);
-		char* tmp4 = cm_strcat3(tmp3, " ", req.version);
+		tmp4 = cm_strcat3(tmp3, " ", req.version);
-		char* tmp5 = cm_strcat3(tmp4, "\" \"", useragent);
+		tmp5 = cm_strcat3(tmp4, "\" \"", useragent);
-		char* log = cm_strcat(tmp5, "\"");
+		log = cm_strcat(tmp5, "\"");
 		free(tmp);
 		free(tmp2);
 		free(tmp3);
 		free(tmp4);
 		free(tmp5);
 		free(useragent);
 		cm_force_log(log);
 		free(log);
-		char* vhost = cm_strdup(config.hostname);
+		vhost = cm_strdup(config.hostname);
-		time_t cmtime = 0;
+		cmtime = 0;
 		if(req.headers != NULL) {
 			for(i = 0; req.headers[i] != NULL; i += 2) {
 				if(cm_strcaseequ(req.headers[i], "Host")) {
 					free(vhost);
 					vhost = cm_strdup(req.headers[i + 1]);
 				} else if(cm_strcaseequ(req.headers[i], "If-Modified-Since")) {
 					struct tm tm;
+					time_t t;
+					struct tm* btm;
 					strptime(req.headers[i + 1], "%a, %d %b %Y %H:%M:%S GMT", &tm);
-#if defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(__ps2sdk__)
+#if defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(__ps2sdk__) || defined(_MSC_VER)
-					time_t t = 0;
+					t = 0;
-					struct tm* btm = localtime(&t);
+					btm = localtime(&t);
 					cmtime = mktime(&tm);
 					cmtime -= (btm->tm_hour * 60 + btm->tm_min) * 60;
 #else
 						cmtime = timegm(&tm);
 #endif
+				}
+			}
+		}
-		bool rej = false;
+		rej = false;
 		cm_log("Server", "Host is %s", vhost);
-		int port = s == NULL ? 80 : 443;
+		port = s == NULL ? 80 : 443;
-		char* host = cm_strdup(vhost);
+		host = cm_strdup(vhost);
 		for(i = 0; vhost[i] != 0; i++) {
 			if(vhost[i] == ':') {
 				host[i] = 0;
 				port = atoi(host + i + 1);
 				break;
+			}
+		}
 		name = host;
 		cm_log("Server", "Hostname is `%s', port is `%d'", host, port);
-		struct tw_config_entry* vhost_entry = tw_vhost_match(host, port);
+		vhost_entry = tw_vhost_match(host, port);
 #ifdef HAS_CHROOT
 		char* chrootpath = vhost_entry->chroot_path != NULL ? vhost_entry->chroot_path : config.root.chroot_path;
 		if(chrootpath != NULL) {
 			if(chdir(chrootpath) == 0) {
 				if(chroot(".") == 0) {
 					break;
+				}
+			}
+		}
 		if(!res._processed) {
+			char* path;
+			char* rpath;
+			struct stat st;
 			cm_log("Server", "Document root is %s", vhost_entry->root == NULL ? "not set" : vhost_entry->root);
-			char* path = cm_strcat(vhost_entry->root == NULL ? "" : vhost_entry->root, req.path);
+			path = cm_strcat(vhost_entry->root == NULL ? "" : vhost_entry->root, req.path);
 			cm_log("Server", "Filesystem path is %s", path);
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
-			char* rpath = cm_strdup(path);
+			rpath = cm_strdup(path);
 			for(i = strlen(rpath) - 1; i >= 0; i--) {
 				if(rpath[i] == '/') {
 					int j;
 					for(j = i + 1; rpath[j] != 0; j++) {
 						if(rpath[j] == ':' || rpath[j] == '.') {
+				}
 				free(n);
+			}
 			free(rpath);
 #endif
-			struct stat st;
 			if(!rej && stat(path, &st) == 0) {
 				if(!tw_permission_allowed(path, addr, req, vhost_entry)) {
 					tw_http_error(s, sock, 403, name, port, vhost_entry);
 				} else if(S_ISDIR(st.st_mode)) {
 					if(req.path[strlen(req.path) - 1] != '/') {
-						cm_log("Server", "Accessing directory without the slash at the end");
 						char* headers[3] = {"Location", cm_strcat(req.path, "/"), NULL};
+						cm_log("Server", "Accessing directory without the slash at the end");
 						_tw_process_page(s, sock, tw_http_status(301), NULL, NULL, NULL, 0, headers, 0, 0);
 						free(headers[1]);
 					} else {
 						char** indexes = vhost_entry->index_count == 0 ? config.root.indexes : vhost_entry->indexes;
 						int index_count = vhost_entry->index_count == 0 ? config.root.index_count : vhost_entry->index_count;
 							char* p = cm_strcat3(path, "/", indexes[i]);
 							FILE* f = fopen(p, "rb");
 							if(f != NULL) {
 								char* ext = NULL;
 								int j;
+								struct stat st;
+								char* mime;
 								for(j = strlen(p) - 1; j >= 0; j--) {
 									if(p[j] == '.') {
 										ext = cm_strdup(p + j);
 										break;
 									} else if(p[j] == '/') {
 										break;
+									}
+								}
-								struct stat st;
 								stat(p, &st);
-								char* mime = tw_get_mime(ext, vhost_entry);
+								mime = tw_get_mime(ext, vhost_entry);
 								tw_process_page(s, sock, tw_http_status(200), mime, f, NULL, st.st_size, 0, 0);
 								fclose(f);
 								if(ext != NULL) free(ext);
 								free(p);
 								found = true;
+							}
 							free(p);
+						}
 						if(!found) {
 							char* str = malloc(1);
+							char** items;
+							int readme;
+							char** readmes;
+							int readme_count;
+							int hp;
 							str[0] = 0;
-							char** items = cm_scandir(path);
+							items = cm_scandir(path);
 							addstring(&str, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n");
 							addstring(&str, "<html>\n");
 							addstring(&str, "	<head>\n");
 							addstring(&str, "		<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n");
 							addstring(&str, "		<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n");
 							addstring(&str, "				<th></th>\n");
 							addstring(&str, "				<th>Filename</th>\n");
 							addstring(&str, "				<th>MIME</th>\n");
 							addstring(&str, "				<th>Size</th>\n");
 							addstring(&str, "			</tr>\n");
-							int readme = -1;
+							readme = -1;
-							char** readmes = vhost_entry->readme_count == 0 ? config.root.readmes : vhost_entry->readmes;
+							readmes = vhost_entry->readme_count == 0 ? config.root.readmes : vhost_entry->readmes;
-							int readme_count = vhost_entry->readme_count == 0 ? config.root.readme_count : vhost_entry->readme_count;
+							readme_count = vhost_entry->readme_count == 0 ? config.root.readme_count : vhost_entry->readme_count;
 							if(items != NULL) {
 								int phase = 0;
 							doit:
 								for(i = 0; items[i] != NULL; i++) {
 									int j;
+									char* ext;
+									char* itm;
+									char* icon;
 									char* fpth = cm_strcat3(path, "/", items[i]);
 									struct stat s;
 									char size[512];
+									char* showmime;
+									char* mime;
 									size[0] = 0;
 									stat(fpth, &s);
 									if(phase == 0 && !S_ISDIR(s.st_mode)) {
 										free(fpth);
 										continue;
 										if(readme != -1) {
 											free(fpth);
 											continue;
+										}
+									}
-									if(s.st_size < 1024ULL) {
+									if(s.st_size < NUM1024) {
 										sprintf(size, "%d", (int)s.st_size);
-									} else if(s.st_size < 1024ULL * 1024) {
+									} else if(s.st_size < NUM1024 * 1024) {
 										sprintf(size, "%.1fK", (double)s.st_size / 1024);
-									} else if(s.st_size < 1024ULL * 1024 * 1024) {
+									} else if(s.st_size < NUM1024 * 1024 * 1024) {
 										sprintf(size, "%.1fM", (double)s.st_size / 1024 / 1024);
-									} else if(s.st_size < 1024ULL * 1024 * 1024 * 1024) {
+									} else if(s.st_size < NUM1024 * 1024 * 1024 * 1024) {
 										sprintf(size, "%.1fG", (double)s.st_size / 1024 / 1024 / 1024);
-									} else if(s.st_size < 1024ULL * 1024 * 1024 * 1024 * 1024) {
+									} else if(s.st_size < NUM1024 * 1024 * 1024 * 1024 * 1024) {
 										sprintf(size, "%.1fT", (double)s.st_size / 1024 / 1024 / 1024 / 1024);
+									}
 									free(fpth);
-									char* ext = NULL;
+									ext = NULL;
 									for(j = strlen(items[i]) - 1; j >= 0; j--) {
 										if(items[i][j] == '.') {
 											ext = cm_strdup(items[i] + j);
 											break;
 										} else if(items[i][j] == '/') {
 											break;
+										}
+									}
-									char* showmime = "";
+									showmime = "";
-									char* mime = tw_get_mime(ext, vhost_entry);
+									mime = tw_get_mime(ext, vhost_entry);
 									if(strcmp(items[i], "../") == 0) {
 										mime = "misc/parent";
 										size[0] = 0;
 									} else if(items[i][strlen(items[i]) - 1] == '/') {
 										mime = "misc/dir";
 										size[0] = 0;
 									} else {
 										showmime = mime;
+									}
-									char* icon = tw_get_icon(mime, vhost_entry);
+									icon = tw_get_icon(mime, vhost_entry);
 									if(ext != NULL) free(ext);
-									char* itm = cm_strdup(items[i]);
+									itm = cm_strdup(items[i]);
 									if(strlen(itm) >= 32) {
 										if(itm[strlen(itm) - 1] == '/') {
 											itm[31] = 0;
 											itm[30] = '/';
 											itm[29] = '.';
 								for(i = 0; items[i] != NULL; i++) free(items[i]);
 								free(items);
+							}
 							addstring(&str, "		</table>\n");
 							if(readme != -1) {
-								addstring(&str, "<hr>\n");
-								char* fpth = cm_strcat3(path, "/", readmes[readme]);
 								struct stat s;
+								FILE* fr;
+								char* fpth;
+								addstring(&str, "<hr>\n");
+								fpth = cm_strcat3(path, "/", readmes[readme]);
 								stat(fpth, &s);
-								FILE* fr = fopen(fpth, "r");
+								fr = fopen(fpth, "r");
 								if(fr != NULL) {
 									char* rmbuf = malloc(s.st_size + 1);
 									rmbuf[s.st_size] = 0;
 									fread(rmbuf, s.st_size, 1, fr);
 									addstring(&str, "<pre><code>%h</code></pre>\n", rmbuf);
 									free(rmbuf);
+								}
 								free(fpth);
+							}
 							addstring(&str, "		<hr>\n");
-							int hp = vhost_entry->hideport == -1 ? config.root.hideport : vhost_entry->hideport;
+							hp = vhost_entry->hideport == -1 ? config.root.hideport : vhost_entry->hideport;
 							if(hp == 0) {
 								addstring(&str, "		<address>%s Server at %s Port %d</address>\n", tw_server, name, port);
 							} else {
 								addstring(&str, "		<address>%s Server at %s</address>\n", tw_server, name, port);
+							}
 							free(str);
+						}
+					}
 				} else {
 					char* ext = NULL;
+					char* mime;
+					FILE* f;
 					for(i = strlen(req.path) - 1; i >= 0; i--) {
 						if(req.path[i] == '.') {
 							ext = cm_strdup(req.path + i);
 							break;
 						} else if(req.path[i] == '/') {
 							break;
+						}
+					}
-					char* mime = tw_get_mime(ext, vhost_entry);
+					mime = tw_get_mime(ext, vhost_entry);
 					if(ext != NULL) free(ext);
-					FILE* f = fopen(path, "rb");
+					f = fopen(path, "rb");
 					if(f == NULL) {
 						tw_http_error(s, sock, 403, name, port, vhost_entry);
 					} else {
 						tw_process_page(s, sock, tw_http_status(200), mime, f, NULL, st.st_size, st.st_mtime, cmtime);
 						fclose(f);
 		SSL_shutdown(s);
+	}
 	SSL_free(s);
 #endif
 	close_socket(sock);
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
-	_endthreadex(0);
+	_endthread(0);
 #elif defined(__HAIKU__)
 		exit_thread(0);
 #endif
+	;
+}
 #ifdef SERVICE
 extern SERVICE_STATUS status;
 extern SERVICE_STATUS_HANDLE status_handle;
 #endif
-#if defined(__MINGW32__) || defined(__HAIKU__)
+#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_MSC_VER)
 struct thread_entry {
 #ifdef __HAIKU__
 	thread_id thread;
 #else
 	HANDLE handle;
 extern int running;
 void tw_server_loop(void) {
 	int i;
+#ifndef USE_POLL
+		fd_set fdset;
+		struct timeval tv;
+#endif
-#if defined(__MINGW32__) || defined(__HAIKU__)
+#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_MSC_VER)
 	struct thread_entry threads[2048];
 	for(i = 0; i < sizeof(threads) / sizeof(threads[0]); i++) {
 		threads[i].used = false;
+	}
 #endif
 	struct pollfd pollfds[sockcount];
 	for(i = 0; i < sockcount; i++) {
 		pollfds[i].fd = sockets[i];
 		pollfds[i].events = POLLIN | POLLPRI;
+	}
-#else
-		fd_set fdset;
-		struct timeval tv;
 #endif
 	while(running) {
+		int ret;
 #ifdef USE_POLL
-		int ret = poll(pollfds, sockcount, 1000);
+		ret = poll(pollfds, sockcount, 1000);
 #else
 			FD_ZERO(&fdset);
 			for(i = 0; i < sockcount; i++) {
 				FD_SET(sockets[i], &fdset);
+			}
 			tv.tv_sec = 1;
 			tv.tv_usec = 0;
 #ifdef __HAIKU__
-			int ret = select(32, &fdset, NULL, NULL, &tv);
+			ret = select(32, &fdset, NULL, NULL, &tv);
 #else
-			int ret = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
+			ret = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
 #endif
 #endif
 		if(ret == -1) {
-#ifndef __MINGW32__
+#if !defined(__MINGW32__) && !defined(_MSC_VER)
 			cm_log("Server", "Select failure: %s", strerror(errno));
 #endif
 			break;
 		} else if(ret == 0) {
 #ifdef SERVICE
 #endif
 				if(cond) {
 					SOCKADDR claddr;
 					socklen_t clen = sizeof(claddr);
 					int sock = accept(sockets[i], (struct sockaddr*)&claddr, &clen);
-					cm_log("Server", "New connection accepted");
-#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_PSP) || defined(__PPU__)
+#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_PSP) || defined(__PPU__) || defined(_MSC_VER)
+					int j;
 					struct pass_entry* e = malloc(sizeof(*e));
+					cm_log("Server", "New connection accepted");
 					e->sock = sock;
+#ifdef _MSC_VER
+					e->ssl = config.ports[i] & (1UL << 31);
+#else
-					e->ssl = config.ports[i] & (1ULL << 32);
+					e->ssl = config.ports[i] & (1ULL << 31);
+#endif
 					e->port = config.ports[i];
 					e->addr = claddr;
 #endif
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_MSC_VER)
-					int j;
-					for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
-						if(threads[j].used) {
-							DWORD ex;
-							GetExitCodeThread(threads[j].handle, &ex);
+					_beginthread(tw_server_pass, 0, e);
-							if(ex != STILL_ACTIVE) {
-								CloseHandle(threads[j].handle);
-								threads[j].used = false;
-							}
-						}
-					}
-					for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
-						if(!threads[j].used) {
-							threads[j].handle = (HANDLE)_beginthreadex(NULL, 0, tw_server_pass, e, 0, NULL);
-							threads[j].used = true;
-							break;
-						}
-					}
 #elif defined(_PSP) || defined(__PPU__)
 						tw_server_pass(e);
 #elif defined(__HAIKU__)
-					int j;
 					for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
 						if(threads[j].used) {
 							thread_info info;
 							bool kill = false;
 							if(get_thread_info(threads[j].thread, &info) == B_OK) {
 #else
 					pid_t pid = fork();
 					if(pid == 0) {
 						int j;
 						for(j = 0; j < sockcount; j++) close_socket(sockets[j]);
-						tw_server_pass(sock, config.ports[i] & (1ULL << 32), config.ports[i], claddr);
+						tw_server_pass(sock, config.ports[i] & (1ULL << 31), config.ports[i], claddr);
 						_exit(0);
 					} else {
 						close_socket(sock);
+					}
 #endif

Subversion Repositories Tewi

(root)/trunk/Server/server.c – Rev 189 → 212