Changeset 212 in Main for trunk


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

compiles on vc6

Location:
trunk
Files:
5 added
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Common/Makefile

    r21 r212  
    11# $Id$
    22
     3OBJ=o
     4STATIC=a
     5AR_FLAGS=rcs
    36include $(PWD)/Platform/$(PLATFORM).mk
    47
    58.PHONY: all clean
    6 .SUFFIXES: .c .o
     9.SUFFIXES: .c .$(OBJ)
    710
    8 OBJS = string.o log.o dir.o
     11OBJS = string.$(OBJ) log.$(OBJ) dir.$(OBJ)
    912
    10 all: common.a
     13all: common.$(STATIC)
    1114
    12 common.a: $(OBJS)
    13         $(AR) rcs $@ $(OBJS)
     15common.$(STATIC): $(OBJS)
     16        $(AR) $(AR_FLAGS)$@ $(OBJS)
    1417
    15 .c.o:
     18.c.$(OBJ):
    1619        $(CC) $(CFLAGS) -c -o $@ $<
    1720
    1821clean:
    19         rm -f *.o *.a
     22        rm -f *.o *.a *.lib

  • trunk/Common/dir.c

    r150 r212  
    66
    77#include <sys/stat.h>
     8#ifndef _MSC_VER
    89#include <dirent.h>
     10#endif
    911#include <stdlib.h>
    1012#include <string.h>
    … …  
    1719
    1820char** cm_scandir(const char* path) {
     21#ifdef _MSC_VER
     22        return NULL;
     23#else
    1924        DIR* dir = opendir(path);
    2025        if(dir != NULL) {
    2126                char** r = malloc(sizeof(*r));
     27                struct dirent* d;
    2228                r[0] = NULL;
    23                 struct dirent* d;
    2429                while((d = readdir(dir)) != NULL) {
    2530                        if(strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0) {
    … …  
    6166                return NULL;
    6267        }
     68#endif
    6369}

  • trunk/Common/log.c

    r191 r212  
    4242
    4343void cm_log(const char* name, const char* log, ...) {
     44        va_list args;
     45        char namebuf[LOGNAME_LENGTH + 1];
     46        int i;
     47        char* result;
     48        char cbuf[2];
    4449        if(!cm_do_log) return;
    45         va_list args;
    4650        va_start(args, log);
    47         char namebuf[LOGNAME_LENGTH + 1];
    4851        memset(namebuf, '.', LOGNAME_LENGTH);
    4952        namebuf[LOGNAME_LENGTH] = 0;
    50         int i;
    5153        for(i = 0; name[i] != 0 && i < LOGNAME_LENGTH; i++) {
    5254                namebuf[i] = name[i];
    5355        }
    5456
    55         char* result = malloc(1);
     57        result = malloc(1);
    5658        result[0] = 0;
    5759
    58         char cbuf[2];
    5960        cbuf[1] = 0;
    6061
    … …  
    7071                                int a = va_arg(args, int);
    7172                                char buf[128];
     73                                char* tmp = result;
    7274                                sprintf(buf, "%d", a);
    73                                 char* tmp = result;
    7475                                result = cm_strcat(tmp, buf);
    7576                                free(tmp);
    7677                        }
    7778                } else {
     79                        char* tmp = result;
    7880                        cbuf[0] = log[i];
    79                         char* tmp = result;
    8081                        result = cm_strcat(tmp, cbuf);
    8182                        free(tmp);

  • trunk/Common/string.c

    r70 r212  
    88
    99char* cm_strcat(const char* a, const char* b) {
     10        char* str;
    1011        if(a == NULL) a = "";
    1112        if(b == NULL) b = "";
    12         char* str = malloc(strlen(a) + strlen(b) + 1);
     13        str = malloc(strlen(a) + strlen(b) + 1);
    1314        memcpy(str, a, strlen(a));
    1415        memcpy(str + strlen(a), b, strlen(b));
    … …  
    2728
    2829bool cm_endswith(const char* str, const char* end) {
     30        int i;
    2931        if(strlen(str) < strlen(end)) return false;
    30         int i;
    3132        for(i = strlen(str) - strlen(end); i < strlen(str); i++) {
    3233                if(str[i] != end[i - strlen(str) + strlen(end)]) return false;
    … …  
    3637
    3738bool cm_nocase_endswith(const char* str, const char* end) {
     39        int i;
    3840        if(strlen(str) < strlen(end)) return false;
    39         int i;
    4041        for(i = strlen(str) - strlen(end); i < strlen(str); i++) {
    4142                if(tolower(str[i]) != tolower(end[i - strlen(str) + strlen(end)])) return false;
    … …  
    7677        int i;
    7778        char** r = malloc(sizeof(*r));
    78         r[0] = NULL;
    7979        char* b = malloc(1);
    80         b[0] = 0;
    8180        char cbuf[2];
    82         cbuf[1] = 0;
    8381        bool dq = false;
    8482        bool sq = false;
     83        r[0] = NULL;
     84        b[0] = 0;
     85        cbuf[1] = 0;
    8586        for(i = 0;; i++) {
    8687                int j;
    … …  
    113114                                sq = !sq;
    114115                        } else {
     116                                char* tmp = b;
    115117                                cbuf[0] = str[i];
    116                                 char* tmp = b;
    117118                                b = cm_strcat(tmp, cbuf);
    118119                                free(tmp);
    … …  
    125126
    126127bool cm_strcaseequ(const char* a, const char* b) {
     128        int i;
    127129        if(a == NULL) return false;
    128130        if(b == NULL) return false;
    129131        if(strlen(a) != strlen(b)) return false;
    130         int i;
    131132        for(i = 0; a[i] != 0; i++) {
    132133                if(tolower(a[i]) != tolower(b[i])) return false;
    … …  
    155156        int i;
    156157        char* result = malloc(1);
     158        char cbuf[2];
    157159        result[0] = 0;
    158         char cbuf[2];
    159160        cbuf[1] = 0;
    160161        for(i = 0; str[i] != 0; i++) {
    … …  
    184185        int i;
    185186        char* result = malloc(1);
     187        char cbuf[2];
    186188        result[0] = 0;
    187         char cbuf[2];
    188189        cbuf[1] = 0;
    189190        for(i = 0; str[i] != 0; i++) {
    … …  
    191192                if('!' <= str[i] && str[i] <= '@' && str[i] != '.' && str[i] != '-' && str[i] != '/' && !('0' <= str[i] && str[i] <= '9')) {
    192193                        char code[4];
     194                        char* tmp = result;
    193195                        sprintf(code, "%%%02X", str[i]);
    194                         char* tmp = result;
    195196                        result = cm_strcat(tmp, code);
    196197                        free(tmp);

  • trunk/Module/Makefile

    r126 r212  
    11# $Id$
    22
     3OBJ=o
     4STATIC=a
    35include $(PWD)/Platform/$(PLATFORM).mk
    46
    57.PHONY: all clean
    6 .SUFFIXES: .c .o $(LIB)
     8.SUFFIXES: .c .$(OBJ) $(LIBSUF)
    79
    8 all: mod_cgi$(LIB) mod_proxy$(LIB)
     10all: mod_cgi$(LIBSUF) mod_proxy$(LIBSUF)
    911
    10 .o$(LIB):
    11         $(CC) $(LDFLAGS) -shared -o $@ $< ../Common/common.a $(LIBS)
     12.$(OBJ)$(LIBSUF):
     13        $(CC) $(LDFLAGS) -shared -o $@ $< ../Common/common.$(STATIC) $(LIBS)
    1214
    13 .c.o:
     15.c.$(OBJ):
    1416        $(CC) $(CFLAGS) -c -o $@ $<
    1517
    1618clean:
    17         rm -f *.o *.so *.a *.dll
     19        rm -f *.o *.so *.a *.dll *.dll

  • trunk/Platform/cygwin.mk

    r168 r212  
    77LIBS =
    88EXEC =
    9 LIB = .so
     9LIBSUF = .so

  • trunk/Platform/generic.mk

    r40 r212  
    77LIBS =
    88EXEC =
    9 LIB = .so
     9LIBSUF = .so

  • trunk/Platform/haiku.mk

    r81 r212  
    77LIBS = -lnetwork
    88EXEC =
    9 LIB = .so
     9LIBSUF = .so

  • trunk/Platform/linux.mk

    r47 r212  
    77LIBS =
    88EXEC =
    9 LIB = .so
     9LIBSUF = .so

  • trunk/Platform/netbsd.mk

    r120 r212  
    77LIBS =
    88EXEC =
    9 LIB = .so
     9LIBSUF = .so

  • trunk/Platform/ps2.mk

    r189 r212  
    99LIBS = -ldebug -lsocket
    1010EXEC = .elf
    11 LIB = .so
     11LIBSUF = .so
    1212MODULE =
    1313SERVADD = mips64r5900el-ps2-elf-strip tewi.elf -o tewi_strip.elf

  • trunk/Platform/ps3.mk

    r197 r212  
    99LIBS = -lnet -lsysmodule -lsysutil -lrt -llv2 -lrsx -lgcm_sys -lpng -lm -lz
    1010EXEC = .elf
    11 LIB = .so
     11LIBSUF = .so
    1212MODULE =
    1313SERVADD = ppu-strip tewi.elf -o tewi_strip.elf

  • trunk/Platform/psp.mk

    r183 r212  
    99LIBS = -lpspgum -lpspgu -lpspdebug -lpspdisplay -lpspge -lpspctrl -lpspnet -lpspnet_apctl -lcglue -lpspwlan
    1010EXEC = .elf
    11 LIB = .so
     11LIBSUF = .so
    1212MODULE =
    1313SERVADD = psp-fixup-imports tewi.elf && psp-strip tewi.elf -o tewi_strip.elf

  • trunk/Server/Makefile

    r197 r212  
    11# $Id$
    22
     3OBJ=o
     4STATIC=a
    35include $(PWD)/Platform/$(PLATFORM).mk
    46
    57.PHONY: all clean
    6 .SUFFIXES: .c .o
     8.SUFFIXES: .c .$(OBJ)
    79
    8 OBJS = main.o version.o config.o server.o http.o module.o strptime.o font.o $(EXTOBJS) $(PREOBJS)
     10OBJS = main.$(OBJ) version.$(OBJ) config.$(OBJ) server.$(OBJ) http.$(OBJ) module.$(OBJ) strptime.$(OBJ) font.$(OBJ) $(EXTOBJS) $(PREOBJS)
    911
    1012all: tewi$(EXEC) $(TARGET)
    … …  
    1214tewi_strip$(EXEC): tewi$(EXEC)
    1315
    14 tewi$(EXEC): $(OBJS) ../Common/common.a
    15         $(CC) $(LDFLAGS) $(EXTLDFLAGS) -o $@ $(OBJS) $(EXTLIBS) ../Common/common.a $(LIBS)
     16tewi$(EXEC): $(OBJS) ../Common/common.$(STATIC)
     17        $(CC) $(LDFLAGS) $(EXTLDFLAGS) -o $@ $(OBJS) $(EXTLIBS) ../Common/common.$(STATIC) $(LIBS)
    1618        $(SERVADD)
    1719
    … …  
    4143        package_finalize $@
    4244
    43 .c.o:
     45.c.$(OBJ):
    4446        $(CC) $(CFLAGS) $(EXTCFLAGS) -c -o $@ $<
    4547
    … …  
    4850
    4951clean:
    50         rm -f *.o tewi *.exe *.res *.elf *.sfo *.pbp *.self *.pkg
     52        rm -f *.o tewi *.exe *.res *.elf *.sfo *.pbp *.self *.pkg *.obj

  • trunk/Server/config.c

    r189 r212  
    1010#include <stdlib.h>
    1111#include <string.h>
     12
     13#ifndef _MSC_VER
    1214#include <unistd.h>
    13 
    14 #ifdef __MINGW32__
     15#endif
     16
     17#if defined(__MINGW32__) || defined(_MSC_VER)
    1518#include <winsock2.h>
    1619#endif
    … …  
    3841again:
    3942        for(i = 0; i < vhost->dir_count; i++) {
     43                char* noslash;
    4044                struct tw_dir_entry* e = &vhost->dirs[i];
    4145                pathstart = false;
    4246                if(strlen(path) >= strlen(e->dir)) {
     47                        int j;
    4348                        pathstart = true;
    44                         int j;
    4549                        for(j = 0; path[j] != 0 && e->dir[j] != 0; j++) {
    4650                                if(path[j] != e->dir[j]) {
    … …  
    5054                        }
    5155                }
    52                 char* noslash = cm_strdup(e->dir);
     56                noslash = cm_strdup(e->dir);
    5357                noslash[strlen(noslash) - 1] = 0;
    5458                if(strcmp(e->dir, path) == 0 || strcmp(noslash, path) == 0 || pathstart) {
    … …  
    120124
    121125int tw_config_read(const char* path) {
    122         cm_log("Config", "Reading %s", path);
    123126        char cbuf[2];
    124         cbuf[1] = 0;
    125127        int ln = 0;
    126128        int ifbr = 0;
    127129        int ignore = -1;
    128         FILE* f = fopen(path, "r");
     130        FILE* f;
     131        cm_log("Config", "Reading %s", path);
     132        f = fopen(path, "r");
     133        cbuf[1] = 0;
    129134        if(f != NULL) {
    130135                char* line = malloc(1);
    131                 line[0] = 0;
    132136                int stop = 0;
    133137                struct tw_config_entry* current = &config.root;
    134138                char* vhost = NULL;
    135139                char* dir = NULL;
     140                line[0] = 0;
    136141                while(stop == 0) {
    137142                        int c = fread(cbuf, 1, 1, f);
    138143                        if(cbuf[0] == '\n' || c <= 0) {
     144                                char* l = cm_trim(line);
    139145                                ln++;
    140                                 char* l = cm_trim(line);
    141146                                if(strlen(l) > 0 && l[0] != '#') {
    142147                                        char** r = cm_split(l, " \t");
    … …  
    227232                                                                stop = 1;
    228233                                                        } else {
     234                                                                int i;
    229235                                                                vhost = cm_strdup(r[1]);
    230236                                                                current = &config.vhosts[config.vhost_count++];
    … …  
    235241                                                                current->readme_count = 0;
    236242                                                                current->hideport = -1;
    237                                                                 int i;
    238243                                                                current->name = cm_strdup(vhost);
    239244                                                                current->port = -1;
    … …  
    262267                                        ) {
    263268                                                for(i = 1; r[i] != NULL; i++) {
     269#ifdef _MSC_VER
     270                                                        uint32_t port = atoi(r[i]);
     271#else
    264272                                                        uint64_t port = atoi(r[i]);
     273#endif
     274                                                        int j;
    265275                                                        cm_log("Config", "Going to listen at port %d%s", (int)port, cm_strcaseequ(r[0], "ListenSSL") ? " with SSL" : "");
    266                                                         if(cm_strcaseequ(r[0], "ListenSSL")) port |= (1ULL << 32);
    267                                                         int j;
     276#ifdef _MSC_VER
     277                                                        if(cm_strcaseequ(r[0], "ListenSSL")) port |= (1UL << 31);
     278#else
     279                                                        if(cm_strcaseequ(r[0], "ListenSSL")) port |= (1ULL << 31);
     280#endif
    268281                                                        for(j = 0; config.ports[j] != -1; j++)
    269282                                                                ;
    … …  
    319332                                                        cm_log("Config", "Missing condition type at line %d", ln);
    320333                                                } else {
     334                                                        bool ign = false;
    321335                                                        ifbr++;
    322                                                         bool ign = false;
    323336                                                        if(cm_strcaseequ(r[1], "False")) {
    324337                                                                ign = true;
    … …  
    429442                                                if(r[0] != NULL) {
    430443                                                        int argc;
     444                                                        int i;
     445                                                        bool called = false;
     446                                                        struct tw_tool tools;
    431447                                                        for(argc = 0; r[argc] != NULL; argc++)
    432448                                                                ;
    433449                                                        stop = 0;
    434                                                         int i;
    435                                                         bool called = false;
    436                                                         struct tw_tool tools;
    437450                                                        tw_init_tools(&tools);
    438451                                                        for(i = 0; i < config.module_count; i++) {

  • trunk/Server/http.c

    r187 r212  
    1616#include <string.h>
    1717
    18 #ifdef __MINGW32__
     18#if defined(__MINGW32__) || defined(_MSC_VER)
    1919#include <winsock2.h>
    2020#else
    … …  
    5454        char cbuf[2];
    5555        int phase = 0;
     56        char* header;
     57        int nl;
    5658
    5759#ifdef USE_POLL
    … …  
    7476        req->version = NULL;
    7577
    76         char* header = malloc(1);
     78        header = malloc(1);
    7779        header[0] = 0;
    78         int nl = 0;
     80        nl = 0;
    7981
    8082        while(1) {
     83                int i;
     84                int len;
     85                        int n;
    8186#ifndef USE_POLL
     87                struct timeval tv;
    8288                FD_ZERO(&fds);
    8389                FD_SET(sock, &fds);
    84                 struct timeval tv;
    8590                tv.tv_sec = 5;
    8691                tv.tv_usec = 0;
    … …  
    9095#endif
    9196#ifdef USE_POLL
    92                         int n = poll(pollfds, 1, 5000);
     97                        n = poll(pollfds, 1, 5000);
    9398#else
    9499#ifdef __HAIKU__
    95                 int n = select(32, &fds, NULL, NULL, &tv);
    96 #else
    97                 int n = select(FD_SETSIZE, &fds, NULL, NULL, &tv);
     100                n = select(32, &fds, NULL, NULL, &tv);
     101#else
     102                n = select(FD_SETSIZE, &fds, NULL, NULL, &tv);
    98103#endif
    99104#endif
    … …  
    107112                }
    108113#endif
    109                 int len = tw_read(ssl, sock, buffer, 512);
     114                len = tw_read(ssl, sock, buffer, 512);
    110115                if(len <= 0) {
    111116                        bad = true;
    112117                        break;
    113118                }
    114                 int i;
    115119                for(i = 0; i < len; i++) {
    116120                        char c = buffer[i];
    … …  
    125129                                        }
    126130                                } else {
     131                                        char* tmp;
    127132                                        if(req->method == NULL) {
    128133                                                req->method = malloc(1);
    … …  
    130135                                        }
    131136                                        cbuf[0] = c;
    132                                         char* tmp = req->method;
     137                                        tmp = req->method;
    133138                                        req->method = cm_strcat(tmp, cbuf);
    134139                                        free(tmp);
    … …  
    144149                                        }
    145150                                } else {
     151                                        char* tmp;
    146152                                        if(req->path == NULL) {
    147153                                                req->path = malloc(1);
    … …  
    149155                                        }
    150156                                        cbuf[0] = c;
    151                                         char* tmp = req->path;
     157                                        tmp = req->path;
    152158                                        req->path = cm_strcat(tmp, cbuf);
    153159                                        free(tmp);
    … …  
    161167                                        } else {
    162168                                                /* We have Method, Path, Version now */
    163 
     169                                                int j;
     170                                                char* p;
     171                                                int incr;
    164172                                                if(strcmp(req->version, "HTTP/1.1") != 0 && strcmp(req->version, "HTTP/1.0") != 0) {
    165173                                                        cm_log("HTTP", "Bad HTTP Version");
    … …  
    168176                                                }
    169177
    170                                                 int j;
    171                                                 char* p = malloc(1);
     178                                                p = malloc(1);
    172179                                                p[0] = 0;
    173180                                                for(j = 0; req->path[j] != 0; j++) {
     181                                                        char* tmp;
    174182                                                        if(req->path[j] == '/') {
    175183                                                                cbuf[0] = '/';
    … …  
    180188                                                                cbuf[0] = req->path[j];
    181189                                                        }
    182                                                         char* tmp = p;
     190                                                        tmp = p;
    183191                                                        p = cm_strcat(tmp, cbuf);
    184192                                                        free(tmp);
    … …  
    187195                                                req->path = p;
    188196
    189                                                 int incr = 0;
     197                                                incr = 0;
    190198                                                p = malloc(1);
    191199                                                p[0] = 0;
    … …  
    193201                                                        if(req->path[j] == '/' || req->path[j] == 0) {
    194202                                                                char oldc = req->path[j];
     203                                                                char* pth;
    195204                                                                cbuf[0] = oldc;
    196205                                                                req->path[j] = 0;
    197206
    198                                                                 char* pth = req->path + incr;
     207                                                                pth = req->path + incr;
    199208
    200209                                                                if(strcmp(pth, "..") == 0) {
    … …  
    230239                                        }
    231240                                } else if(c != '\r') {
     241                                        char* tmp;
    232242                                        if(req->version == NULL) {
    233243                                                req->version = malloc(1);
    … …  
    235245                                        }
    236246                                        cbuf[0] = c;
    237                                         char* tmp = req->version;
     247                                        tmp = req->version;
    238248                                        req->version = cm_strcat(tmp, cbuf);
    239249                                        free(tmp);
    … …  
    246256                                                goto getout;
    247257                                        } else {
     258                                                int j;
    248259                                                if(req->headers == NULL) {
    249260                                                        req->headers = malloc(sizeof(*req->headers));
    250261                                                        req->headers[0] = NULL;
    251262                                                }
    252                                                 int j;
    253263                                                for(j = 0; header[j] != 0; j++) {
    254264                                                        if(header[j] == ':') {
     265                                                                char* kv;
     266                                                                char* vv;
     267                                                                char** old;
     268                                                                int k;
    255269                                                                header[j] = 0;
    256270                                                                j++;
    257271                                                                for(; header[j] != 0 && (header[j] == ' ' || header[j] == '\t'); j++)
    258272                                                                        ;
    259                                                                 char* kv = header;
    260                                                                 char* vv = header + j;
    261 
    262                                                                 char** old = req->headers;
    263                                                                 int k;
     273                                                                kv = header;
     274                                                                vv = header + j;
     275
     276                                                                old = req->headers;
    264277                                                                for(k = 0; old[k] != NULL; k++)
    265278                                                                        ;
    … …  
    281294                                        }
    282295                                } else if(c != '\r') {
     296                                        char* tmp;
    283297                                        nl = 0;
    284298                                        cbuf[0] = c;
    285                                         char* tmp = header;
     299                                        tmp = header;
    286300                                        header = cm_strcat(tmp, cbuf);
    287301                                        free(tmp);
    … …  
    296310                return 1;
    297311        }
    298         char* result = malloc(1);
    299         result[0] = 0;
    300         int i;
    301         for(i = 0; req->path[i] != 0; i++) {
    302                 if(req->path[i] == '?') {
    303                         req->path[i] = 0;
    304                         req->query = cm_strdup(req->path + i + 1);
    305                         break;
    306                 }
    307         }
    308         for(i = 0; req->path[i] != 0; i++) {
    309                 if(req->path[i] == '%') {
    310                         if(req->path[i + 1] == 0) continue;
    311                         cbuf[0] = cm_hex(req->path + i + 1, 2);
    312                         if(cbuf[0] != '\\') {
    313                                 char* tmp = result;
     312        {
     313                char* result = malloc(1);
     314                int i;
     315                int j;
     316                int incr;
     317                char* p;
     318                result[0] = 0;
     319                for(i = 0; req->path[i] != 0; i++) {
     320                        if(req->path[i] == '?') {
     321                                req->path[i] = 0;
     322                                req->query = cm_strdup(req->path + i + 1);
     323                                break;
     324                        }
     325                }
     326                for(i = 0; req->path[i] != 0; i++) {
     327                        if(req->path[i] == '%') {
     328                                if(req->path[i + 1] == 0) continue;
     329                                cbuf[0] = cm_hex(req->path + i + 1, 2);
     330                                if(cbuf[0] != '\\') {
     331                                        char* tmp = result;
     332                                        result = cm_strcat(tmp, cbuf);
     333                                        free(tmp);
     334                                }
     335                                i += 2;
     336                        } else if(req->path[i] != '\\') {
     337                                char* tmp;
     338                                cbuf[0] = req->path[i];
     339                                tmp = result;
    314340                                result = cm_strcat(tmp, cbuf);
    315341                                free(tmp);
    316342                        }
    317                         i += 2;
    318                 } else if(req->path[i] != '\\') {
    319                         cbuf[0] = req->path[i];
    320                         char* tmp = result;
    321                         result = cm_strcat(tmp, cbuf);
    322                         free(tmp);
    323                 }
     343                }
     344                free(req->path);
     345                req->path = result;
     346       
     347                incr = 0;
     348                p = malloc(1);
     349                p[0] = 0;
     350                for(j = 0;; j++) {
     351                        if(req->path[j] == '/' || req->path[j] == 0) {
     352                                char oldc = req->path[j];
     353                                char* pth;
     354                                cbuf[0] = oldc;
     355                                req->path[j] = 0;
     356       
     357                                pth = req->path + incr;
     358       
     359                                if(strcmp(pth, "..") == 0) {
     360                                        int k;
     361                                        if(p[strlen(p) - 1] == '/') p[strlen(p) - 1] = 0;
     362                                        for(k = strlen(p) - 1; k >= 0; k--) {
     363                                                if(p[k] == '/') {
     364                                                        p[k + 1] = 0;
     365                                                        break;
     366                                                }
     367                                        }
     368                                        if(strlen(p) == 0) {
     369                                                free(p);
     370                                                p = cm_strdup("/");
     371                                        }
     372                                } else if(strcmp(pth, ".") == 0) {
     373                                } else {
     374                                        char* tmp = p;
     375                                        p = cm_strcat3(tmp, pth, cbuf);
     376                                        free(tmp);
     377                                }
     378       
     379                                incr = j + 1;
     380                                if(oldc == 0) break;
     381                        }
     382                }
     383                free(req->path);
     384                req->path = p;
     385                return 0;
    324386        }
    325         free(req->path);
    326         req->path = result;
    327 
    328         int incr = 0;
    329         char* p = malloc(1);
    330         p[0] = 0;
    331         int j;
    332         for(j = 0;; j++) {
    333                 if(req->path[j] == '/' || req->path[j] == 0) {
    334                         char oldc = req->path[j];
    335                         cbuf[0] = oldc;
    336                         req->path[j] = 0;
    337 
    338                         char* pth = req->path + incr;
    339 
    340                         if(strcmp(pth, "..") == 0) {
    341                                 int k;
    342                                 if(p[strlen(p) - 1] == '/') p[strlen(p) - 1] = 0;
    343                                 for(k = strlen(p) - 1; k >= 0; k--) {
    344                                         if(p[k] == '/') {
    345                                                 p[k + 1] = 0;
    346                                                 break;
    347                                         }
    348                                 }
    349                                 if(strlen(p) == 0) {
    350                                         free(p);
    351                                         p = cm_strdup("/");
    352                                 }
    353                         } else if(strcmp(pth, ".") == 0) {
    354                         } else {
    355                                 char* tmp = p;
    356                                 p = cm_strcat3(tmp, pth, cbuf);
    357                                 free(tmp);
    358                         }
    359 
    360                         incr = j + 1;
    361                         if(oldc == 0) break;
    362                 }
    363         }
    364         free(req->path);
    365         req->path = p;
    366         return 0;
    367387}

  • trunk/Server/main.c

    r209 r212  
    55#include "../config.h"
    66
     7#ifndef _MSC_VER
    78#include <unistd.h>
     9#endif
    810#include <stdio.h>
    911#include <stdbool.h>
    … …  
    2325#include "tw_version.h"
    2426
    25 #ifdef __MINGW32__
     27#if defined(__MINGW32__) || defined(_MSC_VER)
    2628#include <windows.h>
    2729#endif
    … …  
    6062#define printf(...) tt_printf(__VA_ARGS__)
    6163#define STDERR_LOG(...) tt_printf(__VA_ARGS__)
     64#elif defined(_MSC_VER)
     65void STDERR_LOG(const char* format, ...){
     66        va_list args;
     67        va_start(args, format);
     68        vfprintf(stderr, format, args);
     69        va_end(args);
     70}
    6271#else
    6372#define STDERR_LOG(...) fprintf(stderr, __VA_ARGS__)
    … …  
    7281int startup(int argc, char** argv);
    7382
    74 #ifdef __MINGW32__
     83#if defined(__MINGW32__) || defined(_MSC_VER)
    7584char* get_registry(const char* main, const char* sub) {
    7685        DWORD bufsize = 512;
    … …  
    511520
    512521int main(int argc, char** argv) {
     522        int st;
    513523        logfile = stderr;
    514524#ifdef SERVICE
    … …  
    667677        SleepThread();
    668678#endif
    669         int st = startup(argc, argv);
     679        st = startup(argc, argv);
    670680        if(st != -1) {
    671681#ifdef _PSP
    … …  
    692702int startup(int argc, char** argv) {
    693703        int i;
    694 #ifdef __MINGW32__
     704        char* r;
     705#if defined(__MINGW32__) || defined(_MSC_VER)
    695706        char* confpath = cm_strdup(PREFIX "/etc/tewi.conf");
    696707        char* regpath = get_registry("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Tewi HTTPd", "InstallDir");
    … …  
    770781        }
    771782        sprintf(tw_server, "Tewi/%s (%s)%s", tw_get_version(), tw_get_platform(), config.extension == NULL ? "" : config.extension);
    772         char* r = cm_strcat(tw_server, " running...");
     783        r = cm_strcat(tw_server, " running...");
    773784        cm_force_log(r);
    774785        free(r);
    775 #ifndef __MINGW32__
     786#if !defined(__MINGW32__) && !defined(_MSC_VER)
    776787        signal(SIGCHLD, SIG_IGN);
    777788        signal(SIGPIPE, SIG_IGN);

  • trunk/Server/module.c

    r189 r212  
    1111
    1212#include <string.h>
     13#include <stdlib.h>
     14#ifndef _MSC_VER
    1315#include <unistd.h>
    14 #include <stdlib.h>
     16#endif
    1517
    1618extern struct tw_config config;
    … …  
    2527#else
    2628
    27 #ifdef __MINGW32__
     29#if defined(__MINGW32__) || defined(_MSC_VER)
    2830#include <windows.h>
    2931#else
    … …  
    3335void* tw_module_load(const char* path) {
    3436        char* p = getcwd(NULL, 0);
     37        void* lib;
    3538        chdir(config.server_root);
    36         void* lib;
    37 #ifdef __MINGW32__
     39#if defined(__MINGW32__) || defined(_MSC_VER)
    3840        lib = LoadLibraryA(path);
    3941#else
    … …  
    4951
    5052void* tw_module_symbol(void* mod, const char* sym) {
    51 #ifdef __MINGW32__
     53#if defined(__MINGW32__) || defined(_MSC_VER)
    5254        return GetProcAddress(mod, sym);
    5355#else

  • 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 {

  • trunk/Server/strptime.c

    r182 r212  
    3636//__RCSID("$NetBSD: strptime.c,v 1.62 2017/08/24 01:01:09 ginsbach Exp $");
    3737
    38 #if defined(__MINGW32__)
     38#if defined(__MINGW32__) || defined(_MSC_VER)
    3939
    4040#include <ctype.h>
    … …  
    292292        case 'D':       /* The date as "%y/%m/%d". */
    293293        {
     294            int year;
    294295            new_fmt = HERE_D_FMT;
    295296            LEGAL_ALT(0);
    296297            state |= S_MON | S_MDAY | S_YEAR;
    297             const int year = split_year ? tm->tm_year : 0;
     298            year = split_year ? tm->tm_year : 0;
    298299
    299300            bp = (const unsigned char *)strptime((const char *)bp,
    … …  
    399400
    400401#ifndef TIME_MAX
     402#ifdef _MSC_VER
     403#define TIME_MAX        INT32_MAX
     404#else
    401405#define TIME_MAX        INT64_MAX
     406#endif
    402407#endif
    403408        case 's':       /* seconds since the epoch */
    404409            {
    405410                time_t sse = 0;
     411#ifdef _MSC_VER
     412                uint32_t rulim = TIME_MAX;
     413#else
    406414                uint64_t rulim = TIME_MAX;
     415#endif
    407416
    408417                if (*bp < '0' || *bp > '9') {
    … …  
    417426                } while ((sse * 10 <= TIME_MAX) &&
    418427                     rulim && *bp >= '0' && *bp <= '9');
    419 
     428#ifdef _MSC_VER
     429                if (sse < 0 || (uint32_t)sse > TIME_MAX) {
     430#else
    420431                if (sse < 0 || (uint64_t)sse > TIME_MAX) {
     432#endif
    421433                    bp = NULL;
    422434                    continue;
    423435                }
    424436#ifdef _WIN32
     437#ifdef _MSC_VER
     438                if (1)
     439#else
    425440                if (localtime_s(tm, &sse) == 0)
     441#endif
    426442#else
    427443                if (localtime_r(&sse, tm))

  • trunk/Server/tw_config.h

    r187 r212  
    1515#include <stdbool.h>
    1616
    17 #ifdef __MINGW32__
     17#if defined(__MINGW32__) || defined(_MSC_VER)
    1818#include <winsock2.h>
    1919#define NO_IPV6
    … …  
    4242#define MAX_INDEX 1024
    4343#define MAX_README 8
     44
     45#ifdef _MSC_VER
     46#define NUM1024 1024UL
     47#else
     48#define NUM1024 1024ULL
     49#endif
    4450
    4551enum TW_DIR_TYPE {
    … …  
    8995
    9096struct tw_config {
     97#ifdef _MSC_VER
     98        uint32_t ports[MAX_PORTS + 1];
     99#else
    91100        uint64_t ports[MAX_PORTS + 1]; /* If port & (1 << 32) is non-zero, it is SSL */
     101#endif
    92102        char hostname[1025];
    93103        char* defined[1025];

  • trunk/Server/version.c

    r187 r212  
    1414#elif defined(__linux__)
    1515    "Linux"
    16 #elif defined(__MINGW32__)
     16#elif defined(__MINGW32__) || defined(_MSC_VER)
    1717    "Windows"
    1818#elif defined(__HAIKU__)

  • trunk/config.h.tmpl

    r189 r212  
    1818#endif
    1919
    20 #if defined(__MINGW32__) && defined(USE_POLL)
     20#if (defined(__MINGW32__) || defined(_MSC_VER)) && defined(USE_POLL)
    2121#undef USE_POLL
    2222/* Force select(2) for Windows */
    2323#endif
    2424
    25 #if defined(__MINGW32__) && defined(HAS_CHROOT)
     25#if (defined(__MINGW32__) || defined(_MSC_VER)) && defined(HAS_CHROOT)
    2626#undef HAS_CHROOT
    2727/* Windows should not have chroot */
     28#endif
     29
     30#if defined(_MSC_VER) && !defined(NO_GETADDRINFO)
     31#define NO_GETADDRINFO
     32/* Do not use getaddrinfo */
    2833#endif
    2934
Note: See TracChangeset for help on using the changeset viewer.