Changeset 212 in Main for trunk/Server/http.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/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}
Note: See TracChangeset for help on using the changeset viewer.