Changeset 212 in Main for trunk/Server/server.c


Ignore:
Timestamp:
Oct 3, 2024, 2:44:55 AM (6 weeks ago)
Author:
Nishi
Message:

compiles on vc6

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Server/server.c

    r189 r212  
    1616#include "tw_version.h"
    1717
     18#ifndef _MSC_VER
    1819#include <unistd.h>
     20#endif
    1921#include <string.h>
    2022#include <stdbool.h>
     
    2325#include <stdlib.h>
    2426#include <errno.h>
     27#include <sys/types.h>
    2528#include <sys/stat.h>
    26 #include <sys/types.h>
    2729#include <time.h>
    2830
     
    3133#include <cm_dir.h>
    3234
    33 #ifdef __MINGW32__
     35#if defined(__MINGW32__) || defined(_MSC_VER)
    3436#ifndef NO_GETADDRINFO
    3537#include <ws2tcpip.h>
     
    7072#endif
    7173
     74#ifndef S_ISDIR
     75#define S_ISDIR(x) ((x) & _S_IFDIR)
     76#endif
     77
    7278extern struct tw_config config;
    7379extern char tw_server[];
     
    7884int sockets[MAX_PORTS];
    7985
    80 #ifdef __MINGW32__
     86#if defined(__MINGW32__) || defined(_MSC_VER)
    8187const 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"};
    8288#endif
     
    105111
    106112void close_socket(int sock) {
    107 #if defined(__MINGW32__)
     113#if defined(__MINGW32__) || defined(_MSC_VER)
    108114        closesocket(sock);
    109115#else
     
    114120int tw_server_init(void) {
    115121        int i;
    116 #ifdef __MINGW32__
     122#if defined(__MINGW32__) || defined(_MSC_VER)
    117123        WSADATA wsa;
    118124        WSAStartup(MAKEWORD(2, 0), &wsa);
     
    122128        sockcount = i;
    123129        for(i = 0; config.ports[i] != -1; i++) {
     130                int yes = 1;
     131                int no = 0;
    124132#ifdef NO_IPV6
    125133                int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     
    127135                int sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
    128136#endif
    129 #ifdef __MINGW32__
     137#if defined(__MINGW32__) || defined(_MSC_VER)
    130138                if(sock == INVALID_SOCKET)
    131139#else
     
    136144                        return 1;
    137145                }
    138                 int yes = 1;
    139146                if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*)&yes, sizeof(yes)) < 0) {
    140147                        close_socket(sock);
     
    150157#endif
    151158#ifndef NO_IPV6
    152                 int no = 0;
    153159                if(setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&no, sizeof(no)) < 0) {
    154160                        close_socket(sock);
     
    223229void _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) {
    224230        char construct[512];
     231        size_t incr;
    225232        if(mtime != 0 && cmtime != 0 && mtime <= cmtime) {
    226233                status = "304 Not Modified";
     
    231238                doc = NULL;
    232239        }
     240#ifdef _MSC_VER
     241        sprintf(construct, "%lu", (unsigned long)size);
     242#else
    233243        sprintf(construct, "%llu", (unsigned long long)size);
     244#endif
    234245        tw_write(ssl, sock, "HTTP/1.1 ", 9);
    235246        tw_write(ssl, sock, (char*)status, strlen(status));
     
    256267                }
    257268        }
    258         int i;
    259269        if(headers != NULL) {
     270                int i;
    260271                for(i = 0; headers[i] != NULL; i += 2) {
    261272                        tw_write(ssl, sock, headers[i], strlen(headers[i]));
     
    267278        tw_write(ssl, sock, "\r\n", 2);
    268279        if(doc == NULL && f == NULL) return;
    269         size_t incr = 0;
     280        incr = 0;
    270281        while(1) {
    271282                if(f != NULL) {
     
    308319char* tw_http_default_error(int code, char* name, int port, struct tw_config_entry* vhost) {
    309320        char address[1024];
     321        char* st;
     322        char* st2;
     323        char* buffer;
     324        char* str;
     325        int i;
    310326
    311327        if((vhost->hideport == -1 ? config.root.hideport : vhost->hideport) == 1) {
     
    315331        }
    316332
    317         char* st = cm_strdup(tw_http_status(code));
    318         char* st2;
    319         int i;
     333        st = cm_strdup(tw_http_status(code));
    320334        for(i = 0; st[i] != 0; i++) {
    321335                if(st[i] == ' ') {
     
    324338                }
    325339        }
    326         char* buffer = malloc(4096);
    327         char* str = cm_strcat3(ERROR_HTML);
     340        buffer = malloc(4096);
     341        str = cm_strcat3(ERROR_HTML);
    328342        sprintf(buffer, str, st, st2);
    329343        free(str);
     
    341355        int i;
    342356        char cbuf[2];
     357        va_list va;
    343358        cbuf[1] = 0;
    344         va_list va;
    345359        va_start(va, add);
    346360        for(i = 0; add[i] != 0; i++) {
     
    367381                                int n = va_arg(va, int);
    368382                                char* h = malloc(512);
     383                                char* tmp = *str;
    369384                                sprintf(h, "%d", n);
    370                                 char* tmp = *str;
    371385                                *str = cm_strcat(tmp, h);
    372386                                free(tmp);
     
    388402char* tw_get_mime(const char* ext, struct tw_config_entry* vhost_entry) {
    389403        char* mime = "application/octet-stream";
    390         if(ext == NULL) return mime;
    391404        bool set = false;
    392405        int i;
     406        if(ext == NULL) return mime;
    393407        for(i = 0; i < vhost_entry->mime_count; i++) {
    394408                if(strcmp(vhost_entry->mimes[i].ext, "all") == 0 || (ext != NULL && tw_wildcard_match(vhost_entry->mimes[i].ext, ext))) {
     
    409423char* tw_get_icon(const char* mime, struct tw_config_entry* vhost_entry) {
    410424        char* icon = "";
    411         if(mime == NULL) return "";
    412425        bool set = false;
    413426        int i;
     427        if(mime == NULL) return "";
    414428        for(i = 0; i < vhost_entry->icon_count; i++) {
    415429                if(strcmp(vhost_entry->icons[i].mime, "all") == 0 || (mime != NULL && tw_wildcard_match(vhost_entry->icons[i].mime, mime))) {
     
    435449};
    436450
    437 #ifdef __MINGW32__
     451#if defined(__MINGW32__) || defined(_MSC_VER)
    438452unsigned int WINAPI tw_server_pass(void* ptr) {
    439453#elif defined(__HAIKU__)
     
    442456int tw_server_pass(void* ptr) {
    443457#endif
    444 #if defined(__HAIKU__) || defined(__MINGW32__) || defined(_PSP) || defined(__PPU__)
     458#if defined(__HAIKU__) || defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(_MSC_VER)
     459#define FREE_PTR
    445460        int sock = ((struct pass_entry*)ptr)->sock;
    446461        bool ssl = ((struct pass_entry*)ptr)->ssl;
    447462        int port = ((struct pass_entry*)ptr)->port;
    448463        SOCKADDR addr = ((struct pass_entry*)ptr)->addr;
    449         free(ptr);
    450464#else
    451465        void tw_server_pass(int sock, bool ssl, int port, SOCKADDR addr) {
    452466#endif
    453         char* name = config.hostname;
    454 
     467        SSL* s = NULL;
    455468#ifndef NO_SSL
    456469        SSL_CTX* ctx = NULL;
    457         SSL* s = NULL;
    458470        bool sslworks = false;
    459471        if(ssl) {
     
    464476                sslworks = true;
    465477        }
    466 #else
    467                 void* s = NULL;
    468 #endif
    469 
     478#endif
     479        char* name = config.hostname;
    470480        char address[513];
    471         address[0] = 0;
     481        int ret;
     482        struct tw_http_request req;
     483        struct tw_http_response res;
     484        struct tw_tool tools;
    472485#ifndef NO_GETADDRINFO
    473486        struct sockaddr* sa = (struct sockaddr*)&addr;
    474487        getnameinfo(sa, sizeof(addr), address, 512, NULL, 0, NI_NUMERICHOST);
    475488#endif
    476 
    477         struct tw_http_request req;
    478         struct tw_http_response res;
    479         struct tw_tool tools;
     489        address[0] = 0;
     490#ifdef FREE_PTR
     491        free(ptr);
     492#endif
     493
    480494        res._processed = false;
    481495        tw_init_tools(&tools);
    482         int ret = tw_http_parse(s, sock, &req);
     496        ret = tw_http_parse(s, sock, &req);
    483497        if(ret == 0) {
    484498                char date[513];
    485499                time_t t = time(NULL);
    486500                struct tm* tm = localtime(&t);
     501                char* useragent = cm_strdup("");
     502                int i;
     503                char* tmp;
     504                char* tmp2;
     505                char* tmp3;
     506                char* tmp4;
     507                char* tmp5;
     508                char* log;
     509                char* vhost;
     510                time_t cmtime;
     511                bool rej;
     512                char* host;
     513                int port;
     514                struct tw_config_entry* vhost_entry;
    487515                strftime(date, 512, "%a, %d %b %Y %H:%M:%S %Z", tm);
    488516
    489                 char* useragent = cm_strdup("");
    490 
    491                 int i;
    492517                for(i = 0; req.headers[i] != NULL; i += 2) {
    493518                        if(cm_strcaseequ(req.headers[i], "User-Agent")) {
     
    497522                }
    498523
    499                 char* tmp = cm_strcat3(address, " - [", date);
    500                 char* tmp2 = cm_strcat3(tmp, "] \"", req.method);
    501                 char* tmp3 = cm_strcat3(tmp2, " ", req.path);
    502                 char* tmp4 = cm_strcat3(tmp3, " ", req.version);
    503                 char* tmp5 = cm_strcat3(tmp4, "\" \"", useragent);
    504                 char* log = cm_strcat(tmp5, "\"");
     524                tmp = cm_strcat3(address, " - [", date);
     525                tmp2 = cm_strcat3(tmp, "] \"", req.method);
     526                tmp3 = cm_strcat3(tmp2, " ", req.path);
     527                tmp4 = cm_strcat3(tmp3, " ", req.version);
     528                tmp5 = cm_strcat3(tmp4, "\" \"", useragent);
     529                log = cm_strcat(tmp5, "\"");
    505530                free(tmp);
    506531                free(tmp2);
     
    512537                free(log);
    513538
    514                 char* vhost = cm_strdup(config.hostname);
    515                 time_t cmtime = 0;
     539                vhost = cm_strdup(config.hostname);
     540                cmtime = 0;
    516541                if(req.headers != NULL) {
    517542                        for(i = 0; req.headers[i] != NULL; i += 2) {
     
    521546                                } else if(cm_strcaseequ(req.headers[i], "If-Modified-Since")) {
    522547                                        struct tm tm;
     548                                        time_t t;
     549                                        struct tm* btm;
    523550                                        strptime(req.headers[i + 1], "%a, %d %b %Y %H:%M:%S GMT", &tm);
    524 #if defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(__ps2sdk__)
    525                                         time_t t = 0;
    526                                         struct tm* btm = localtime(&t);
     551#if defined(__MINGW32__) || defined(_PSP) || defined(__PPU__) || defined(__ps2sdk__) || defined(_MSC_VER)
     552                                        t = 0;
     553                                        btm = localtime(&t);
    527554                                        cmtime = mktime(&tm);
    528555                                        cmtime -= (btm->tm_hour * 60 + btm->tm_min) * 60;
     
    533560                        }
    534561                }
    535                 bool rej = false;
     562                rej = false;
    536563                cm_log("Server", "Host is %s", vhost);
    537                 int port = s == NULL ? 80 : 443;
    538                 char* host = cm_strdup(vhost);
     564                port = s == NULL ? 80 : 443;
     565                host = cm_strdup(vhost);
    539566                for(i = 0; vhost[i] != 0; i++) {
    540567                        if(vhost[i] == ':') {
     
    546573                name = host;
    547574                cm_log("Server", "Hostname is `%s', port is `%d'", host, port);
    548                 struct tw_config_entry* vhost_entry = tw_vhost_match(host, port);
     575                vhost_entry = tw_vhost_match(host, port);
    549576#ifdef HAS_CHROOT
    550577                char* chrootpath = vhost_entry->chroot_path != NULL ? vhost_entry->chroot_path : config.root.chroot_path;
     
    582609                }
    583610                if(!res._processed) {
     611                        char* path;
     612                        char* rpath;
     613                        struct stat st;
    584614                        cm_log("Server", "Document root is %s", vhost_entry->root == NULL ? "not set" : vhost_entry->root);
    585                         char* path = cm_strcat(vhost_entry->root == NULL ? "" : vhost_entry->root, req.path);
     615                        path = cm_strcat(vhost_entry->root == NULL ? "" : vhost_entry->root, req.path);
    586616                        cm_log("Server", "Filesystem path is %s", path);
    587 #ifdef __MINGW32__
    588                         char* rpath = cm_strdup(path);
     617#if defined(__MINGW32__) || defined(_MSC_VER)
     618                        rpath = cm_strdup(path);
    589619                        for(i = strlen(rpath) - 1; i >= 0; i--) {
    590620                                if(rpath[i] == '/') {
     
    612642                        free(rpath);
    613643#endif
    614                         struct stat st;
    615644                        if(!rej && stat(path, &st) == 0) {
    616645                                if(!tw_permission_allowed(path, addr, req, vhost_entry)) {
     
    618647                                } else if(S_ISDIR(st.st_mode)) {
    619648                                        if(req.path[strlen(req.path) - 1] != '/') {
     649                                                char* headers[3] = {"Location", cm_strcat(req.path, "/"), NULL};
    620650                                                cm_log("Server", "Accessing directory without the slash at the end");
    621                                                 char* headers[3] = {"Location", cm_strcat(req.path, "/"), NULL};
    622651                                                _tw_process_page(s, sock, tw_http_status(301), NULL, NULL, NULL, 0, headers, 0, 0);
    623652                                                free(headers[1]);
     
    632661                                                                char* ext = NULL;
    633662                                                                int j;
     663                                                                struct stat st;
     664                                                                char* mime;
    634665                                                                for(j = strlen(p) - 1; j >= 0; j--) {
    635666                                                                        if(p[j] == '.') {
     
    640671                                                                        }
    641672                                                                }
    642                                                                 struct stat st;
    643673                                                                stat(p, &st);
    644                                                                 char* mime = tw_get_mime(ext, vhost_entry);
     674                                                                mime = tw_get_mime(ext, vhost_entry);
    645675                                                                tw_process_page(s, sock, tw_http_status(200), mime, f, NULL, st.st_size, 0, 0);
    646676                                                                fclose(f);
     
    654684                                                if(!found) {
    655685                                                        char* str = malloc(1);
     686                                                        char** items;
     687                                                        int readme;
     688                                                        char** readmes;
     689                                                        int readme_count;
     690                                                        int hp;
    656691                                                        str[0] = 0;
    657                                                         char** items = cm_scandir(path);
     692                                                        items = cm_scandir(path);
    658693                                                        addstring(&str, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n");
    659694                                                        addstring(&str, "<html>\n");
     
    673708                                                        addstring(&str, "                               <th>Size</th>\n");
    674709                                                        addstring(&str, "                       </tr>\n");
    675                                                         int readme = -1;
    676                                                         char** readmes = vhost_entry->readme_count == 0 ? config.root.readmes : vhost_entry->readmes;
    677                                                         int readme_count = vhost_entry->readme_count == 0 ? config.root.readme_count : vhost_entry->readme_count;
     710                                                        readme = -1;
     711                                                        readmes = vhost_entry->readme_count == 0 ? config.root.readmes : vhost_entry->readmes;
     712                                                        readme_count = vhost_entry->readme_count == 0 ? config.root.readme_count : vhost_entry->readme_count;
    678713                                                        if(items != NULL) {
    679714                                                                int phase = 0;
     
    681716                                                                for(i = 0; items[i] != NULL; i++) {
    682717                                                                        int j;
     718                                                                        char* ext;
     719                                                                        char* itm;
     720                                                                        char* icon;
    683721                                                                        char* fpth = cm_strcat3(path, "/", items[i]);
    684722                                                                        struct stat s;
    685723                                                                        char size[512];
     724                                                                        char* showmime;
     725                                                                        char* mime;
    686726                                                                        size[0] = 0;
    687727                                                                        stat(fpth, &s);
     
    705745                                                                                }
    706746                                                                        }
    707                                                                         if(s.st_size < 1024ULL) {
     747                                                                        if(s.st_size < NUM1024) {
    708748                                                                                sprintf(size, "%d", (int)s.st_size);
    709                                                                         } else if(s.st_size < 1024ULL * 1024) {
     749                                                                        } else if(s.st_size < NUM1024 * 1024) {
    710750                                                                                sprintf(size, "%.1fK", (double)s.st_size / 1024);
    711                                                                         } else if(s.st_size < 1024ULL * 1024 * 1024) {
     751                                                                        } else if(s.st_size < NUM1024 * 1024 * 1024) {
    712752                                                                                sprintf(size, "%.1fM", (double)s.st_size / 1024 / 1024);
    713                                                                         } else if(s.st_size < 1024ULL * 1024 * 1024 * 1024) {
     753                                                                        } else if(s.st_size < NUM1024 * 1024 * 1024 * 1024) {
    714754                                                                                sprintf(size, "%.1fG", (double)s.st_size / 1024 / 1024 / 1024);
    715                                                                         } else if(s.st_size < 1024ULL * 1024 * 1024 * 1024 * 1024) {
     755                                                                        } else if(s.st_size < NUM1024 * 1024 * 1024 * 1024 * 1024) {
    716756                                                                                sprintf(size, "%.1fT", (double)s.st_size / 1024 / 1024 / 1024 / 1024);
    717757                                                                        }
     
    719759                                                                        free(fpth);
    720760
    721                                                                         char* ext = NULL;
     761                                                                        ext = NULL;
    722762                                                                        for(j = strlen(items[i]) - 1; j >= 0; j--) {
    723763                                                                                if(items[i][j] == '.') {
     
    728768                                                                                }
    729769                                                                        }
    730                                                                         char* showmime = "";
    731                                                                         char* mime = tw_get_mime(ext, vhost_entry);
     770                                                                        showmime = "";
     771                                                                        mime = tw_get_mime(ext, vhost_entry);
    732772                                                                        if(strcmp(items[i], "../") == 0) {
    733773                                                                                mime = "misc/parent";
     
    739779                                                                                showmime = mime;
    740780                                                                        }
    741                                                                         char* icon = tw_get_icon(mime, vhost_entry);
     781                                                                        icon = tw_get_icon(mime, vhost_entry);
    742782                                                                        if(ext != NULL) free(ext);
    743                                                                         char* itm = cm_strdup(items[i]);
     783                                                                        itm = cm_strdup(items[i]);
    744784                                                                        if(strlen(itm) >= 32) {
    745785                                                                                if(itm[strlen(itm) - 1] == '/') {
     
    771811                                                        addstring(&str, "               </table>\n");
    772812                                                        if(readme != -1) {
     813                                                                struct stat s;
     814                                                                FILE* fr;
     815                                                                char* fpth;
    773816                                                                addstring(&str, "<hr>\n");
    774                                                                 char* fpth = cm_strcat3(path, "/", readmes[readme]);
    775                                                                 struct stat s;
     817                                                                fpth = cm_strcat3(path, "/", readmes[readme]);
    776818                                                                stat(fpth, &s);
    777                                                                 FILE* fr = fopen(fpth, "r");
     819                                                                fr = fopen(fpth, "r");
    778820                                                                if(fr != NULL) {
    779821                                                                        char* rmbuf = malloc(s.st_size + 1);
     
    787829                                                        }
    788830                                                        addstring(&str, "               <hr>\n");
    789                                                         int hp = vhost_entry->hideport == -1 ? config.root.hideport : vhost_entry->hideport;
     831                                                        hp = vhost_entry->hideport == -1 ? config.root.hideport : vhost_entry->hideport;
    790832                                                        if(hp == 0) {
    791833                                                                addstring(&str, "               <address>%s Server at %s Port %d</address>\n", tw_server, name, port);
     
    801843                                } else {
    802844                                        char* ext = NULL;
     845                                        char* mime;
     846                                        FILE* f;
    803847                                        for(i = strlen(req.path) - 1; i >= 0; i--) {
    804848                                                if(req.path[i] == '.') {
     
    809853                                                }
    810854                                        }
    811                                         char* mime = tw_get_mime(ext, vhost_entry);
     855                                        mime = tw_get_mime(ext, vhost_entry);
    812856                                        if(ext != NULL) free(ext);
    813                                         FILE* f = fopen(path, "rb");
     857                                        f = fopen(path, "rb");
    814858                                        if(f == NULL) {
    815859                                                tw_http_error(s, sock, 403, name, port, vhost_entry);
     
    841885#endif
    842886        close_socket(sock);
    843 #ifdef __MINGW32__
    844         _endthreadex(0);
     887#if defined(__MINGW32__) || defined(_MSC_VER)
     888        _endthread(0);
    845889#elif defined(__HAIKU__)
    846890                exit_thread(0);
     
    854898#endif
    855899
    856 #if defined(__MINGW32__) || defined(__HAIKU__)
     900#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_MSC_VER)
    857901struct thread_entry {
    858902#ifdef __HAIKU__
     
    869913void tw_server_loop(void) {
    870914        int i;
    871 #if defined(__MINGW32__) || defined(__HAIKU__)
     915#ifndef USE_POLL
     916                fd_set fdset;
     917                struct timeval tv;
     918#endif
     919#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_MSC_VER)
    872920        struct thread_entry threads[2048];
    873921        for(i = 0; i < sizeof(threads) / sizeof(threads[0]); i++) {
     
    881929                pollfds[i].events = POLLIN | POLLPRI;
    882930        }
    883 #else
    884                 fd_set fdset;
    885                 struct timeval tv;
    886931#endif
    887932        while(running) {
     933                int ret;
    888934#ifdef USE_POLL
    889                 int ret = poll(pollfds, sockcount, 1000);
     935                ret = poll(pollfds, sockcount, 1000);
    890936#else
    891937                        FD_ZERO(&fdset);
     
    896942                        tv.tv_usec = 0;
    897943#ifdef __HAIKU__
    898                         int ret = select(32, &fdset, NULL, NULL, &tv);
    899 #else
    900                         int ret = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
     944                        ret = select(32, &fdset, NULL, NULL, &tv);
     945#else
     946                        ret = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
    901947#endif
    902948#endif
    903949                if(ret == -1) {
    904 #ifndef __MINGW32__
     950#if !defined(__MINGW32__) && !defined(_MSC_VER)
    905951                        cm_log("Server", "Select failure: %s", strerror(errno));
    906952#endif
     
    926972                                        socklen_t clen = sizeof(claddr);
    927973                                        int sock = accept(sockets[i], (struct sockaddr*)&claddr, &clen);
     974#if defined(__MINGW32__) || defined(__HAIKU__) || defined(_PSP) || defined(__PPU__) || defined(_MSC_VER)
     975                                        int j;
     976                                        struct pass_entry* e = malloc(sizeof(*e));
    928977                                        cm_log("Server", "New connection accepted");
    929 #if defined(__MINGW32__) || defined(__HAIKU__) || defined(_PSP) || defined(__PPU__)
    930                                         struct pass_entry* e = malloc(sizeof(*e));
    931978                                        e->sock = sock;
    932                                         e->ssl = config.ports[i] & (1ULL << 32);
     979#ifdef _MSC_VER
     980                                        e->ssl = config.ports[i] & (1UL << 31);
     981#else
     982                                        e->ssl = config.ports[i] & (1ULL << 31);
     983#endif
    933984                                        e->port = config.ports[i];
    934985                                        e->addr = claddr;
    935986#endif
    936 #ifdef __MINGW32__
    937                                         int j;
    938                                         for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
    939                                                 if(threads[j].used) {
    940                                                         DWORD ex;
    941                                                         GetExitCodeThread(threads[j].handle, &ex);
    942                                                         if(ex != STILL_ACTIVE) {
    943                                                                 CloseHandle(threads[j].handle);
    944                                                                 threads[j].used = false;
    945                                                         }
    946                                                 }
    947                                         }
    948                                         for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
    949                                                 if(!threads[j].used) {
    950                                                         threads[j].handle = (HANDLE)_beginthreadex(NULL, 0, tw_server_pass, e, 0, NULL);
    951                                                         threads[j].used = true;
    952                                                         break;
    953                                                 }
    954                                         }
     987#if defined(__MINGW32__) || defined(_MSC_VER)
     988                                        _beginthread(tw_server_pass, 0, e);
    955989#elif defined(_PSP) || defined(__PPU__)
    956990                                                tw_server_pass(e);
    957991#elif defined(__HAIKU__)
    958                                         int j;
    959992                                        for(j = 0; j < sizeof(threads) / sizeof(threads[0]); j++) {
    960993                                                if(threads[j].used) {
     
    9831016                                                int j;
    9841017                                                for(j = 0; j < sockcount; j++) close_socket(sockets[j]);
    985                                                 tw_server_pass(sock, config.ports[i] & (1ULL << 32), config.ports[i], claddr);
     1018                                                tw_server_pass(sock, config.ports[i] & (1ULL << 31), config.ports[i], claddr);
    9861019                                                _exit(0);
    9871020                                        } else {
Note: See TracChangeset for help on using the changeset viewer.