Changeset 32704


Ignore:
Timestamp:
2012-07-13T19:10:56+02:00 (6 years ago)
Author:
jow
Message:

[package] uhttpd: various changes

  • remove unused variables
  • simply ignore command line args which belong to not enabled features
  • resolve peer address at accept() time, should solve (#11850)
  • remove floating point operations where possible
Location:
trunk/package/uhttpd
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/uhttpd/Makefile

    r32662 r32704  
    99 
    1010PKG_NAME:=uhttpd 
    11 PKG_RELEASE:=39 
     11PKG_RELEASE:=40 
    1212 
    1313PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
  • trunk/package/uhttpd/src/uhttpd-cgi.c

    r32662 r32704  
    202202                                /* write status */ 
    203203                                ensure_out(uh_http_sendf(cl, NULL, 
    204                                         "HTTP/%.1f %03d %s\r\n" 
     204                                        "%s %03d %s\r\n" 
    205205                                        "Connection: close\r\n", 
    206                                         req->version, res->statuscode, res->statusmsg)); 
     206                                        http_versions[req->version], 
     207                                        res->statuscode, res->statusmsg)); 
    207208 
    208209                                /* add Content-Type if no Location or Content-Type */ 
     
    215216 
    216217                                /* if request was HTTP 1.1 we'll respond chunked */ 
    217                                 if ((req->version > 1.0) && 
     218                                if ((req->version > UH_HTTP_VER_1_0) && 
    218219                                        !uh_cgi_header_lookup(res, "Transfer-Encoding")) 
    219220                                { 
     
    261262 
    262263                                ensure_out(uh_http_sendf(cl, NULL, 
    263                                                                                  "HTTP/%.1f 200 OK\r\n" 
     264                                                                                 "%s 200 OK\r\n" 
    264265                                                                                 "Content-Type: text/plain\r\n" 
    265266                                                                                 "%s\r\n", 
    266                                                                                  req->version, (req->version > 1.0) 
     267                                                                                 http_versions[req->version], 
     268                                                                                 (req->version > UH_HTTP_VER_1_0) 
    267269                                                                                 ? "Transfer-Encoding: chunked\r\n" : "" 
    268270                                )); 
     
    428430 
    429431                        /* http version */ 
    430                         if (req->version > 1.0) 
    431                                 setenv("SERVER_PROTOCOL", "HTTP/1.1", 1); 
    432                         else 
    433                                 setenv("SERVER_PROTOCOL", "HTTP/1.0", 1); 
     432                        setenv("SERVER_PROTOCOL", http_versions[req->version], 1); 
    434433 
    435434                        /* request method */ 
    436                         switch (req->method) 
    437                         { 
    438                                 case UH_HTTP_MSG_GET: 
    439                                         setenv("REQUEST_METHOD", "GET", 1); 
    440                                         break; 
    441  
    442                                 case UH_HTTP_MSG_HEAD: 
    443                                         setenv("REQUEST_METHOD", "HEAD", 1); 
    444                                         break; 
    445  
    446                                 case UH_HTTP_MSG_POST: 
    447                                         setenv("REQUEST_METHOD", "POST", 1); 
    448                                         break; 
    449                         } 
     435                        setenv("REQUEST_METHOD", http_methods[req->method], 1); 
    450436 
    451437                        /* request url */ 
  • trunk/package/uhttpd/src/uhttpd-file.c

    r31931 r32704  
    114114static int uh_file_response_200(struct client *cl, struct stat *s) 
    115115{ 
    116         ensure_ret(uh_http_sendf(cl, NULL, "HTTP/%.1f 200 OK\r\n", 
    117                                                          cl->request.version)); 
     116        ensure_ret(uh_http_sendf(cl, NULL, "%s 200 OK\r\n", 
     117                                                         http_versions[cl->request.version])); 
    118118 
    119119        return uh_file_response_ok_hdrs(cl, s); 
     
    122122static int uh_file_response_304(struct client *cl, struct stat *s) 
    123123{ 
    124         ensure_ret(uh_http_sendf(cl, NULL, "HTTP/%.1f 304 Not Modified\r\n", 
    125                                                          cl->request.version)); 
     124        ensure_ret(uh_http_sendf(cl, NULL, "%s 304 Not Modified\r\n", 
     125                                                         http_versions[cl->request.version])); 
    126126 
    127127        return uh_file_response_ok_hdrs(cl, s); 
     
    131131{ 
    132132        return uh_http_sendf(cl, NULL, 
    133                                                  "HTTP/%.1f 412 Precondition Failed\r\n" 
    134                                                  "Connection: close\r\n", cl->request.version); 
     133                                                 "%s 412 Precondition Failed\r\n" 
     134                                                 "Connection: close\r\n", 
     135                             http_versions[cl->request.version]); 
    135136} 
    136137 
  • trunk/package/uhttpd/src/uhttpd-lua.c

    r32651 r32704  
    6767} 
    6868 
    69 static int uh_lua_send_common(lua_State *L, int chunked) 
     69static int uh_lua_send_common(lua_State *L, bool chunked) 
    7070{ 
    7171        size_t length; 
     
    113113static int uh_lua_send(lua_State *L) 
    114114{ 
    115         return uh_lua_send_common(L, 0); 
     115        return uh_lua_send_common(L, false); 
    116116} 
    117117 
    118118static int uh_lua_sendc(lua_State *L) 
    119119{ 
    120         return uh_lua_send_common(L, 1); 
     120        return uh_lua_send_common(L, true); 
    121121} 
    122122 
     
    415415 
    416416                /* request method */ 
    417                 switch(req->method) 
    418                 { 
    419                         case UH_HTTP_MSG_GET: 
    420                                 lua_pushstring(L, "GET"); 
    421                                 break; 
    422  
    423                         case UH_HTTP_MSG_HEAD: 
    424                                 lua_pushstring(L, "HEAD"); 
    425                                 break; 
    426  
    427                         case UH_HTTP_MSG_POST: 
    428                                 lua_pushstring(L, "POST"); 
    429                                 break; 
    430                 } 
    431  
     417                lua_pushstring(L, http_methods[req->method]); 
    432418                lua_setfield(L, -2, "REQUEST_METHOD"); 
    433419 
     
    463449 
    464450                /* http protcol version */ 
    465                 lua_pushnumber(L, floor(req->version * 10) / 10); 
     451                lua_pushnumber(L, 0.9 + (req->version / 10.0)); 
    466452                lua_setfield(L, -2, "HTTP_VERSION"); 
    467453 
    468                 if (req->version > 1.0) 
    469                         lua_pushstring(L, "HTTP/1.1"); 
    470                 else 
    471                         lua_pushstring(L, "HTTP/1.0"); 
    472  
     454                lua_pushstring(L, http_versions[req->version]); 
    473455                lua_setfield(L, -2, "SERVER_PROTOCOL"); 
    474456 
     
    530512                                        err_str = "Unknown error"; 
    531513 
    532                                 printf("HTTP/%.1f 500 Internal Server Error\r\n" 
     514                                printf("%s 500 Internal Server Error\r\n" 
    533515                                           "Connection: close\r\n" 
    534516                                           "Content-Type: text/plain\r\n" 
    535517                                           "Content-Length: %i\r\n\r\n" 
    536518                                           "Lua raised a runtime error:\n  %s\n", 
    537                                            req->version, 31 + strlen(err_str), err_str); 
     519                                           http_versions[req->version], 
     520                                           31 + strlen(err_str), err_str); 
    538521 
    539522                                break; 
  • trunk/package/uhttpd/src/uhttpd-utils.c

    r32651 r32704  
    335335        va_end(ap); 
    336336 
    337         if ((req != NULL) && (req->version > 1.0)) 
     337        if ((req != NULL) && (req->version > UH_HTTP_VER_1_0)) 
    338338                ensure_ret(uh_http_sendc(cl, buffer, len)); 
    339339        else if (len > 0) 
     
    349349                len = strlen(buf); 
    350350 
    351         if ((req != NULL) && (req->version > 1.0)) 
     351        if ((req != NULL) && (req->version > UH_HTTP_VER_1_0)) 
    352352                ensure_ret(uh_http_sendc(cl, buf, len)); 
    353353        else if (len > 0) 
     
    866866                /* 401 */ 
    867867                uh_http_sendf(cl, NULL, 
    868                         "HTTP/%.1f 401 Authorization Required\r\n" 
    869                         "WWW-Authenticate: Basic realm=\"%s\"\r\n" 
    870                         "Content-Type: text/plain\r\n" 
    871                         "Content-Length: 23\r\n\r\n" 
    872                         "Authorization Required\n", 
    873                                 req->version, cl->server->conf->realm 
    874                 ); 
     868                              "%s 401 Authorization Required\r\n" 
     869                              "WWW-Authenticate: Basic realm=\"%s\"\r\n" 
     870                              "Content-Type: text/plain\r\n" 
     871                              "Content-Length: 23\r\n\r\n" 
     872                              "Authorization Required\n", 
     873                              http_versions[req->version], 
     874                              cl->server->conf->realm); 
    875875 
    876876                return 0; 
     
    923923 
    924924 
    925 struct client * uh_client_add(int sock, struct listener *serv) 
     925struct client * uh_client_add(int sock, struct listener *serv, 
     926                              struct sockaddr_in6 *peer) 
    926927{ 
    927928        struct client *new = NULL; 
     
    931932        { 
    932933                memset(new, 0, sizeof(struct client)); 
     934                memcpy(&new->peeraddr, peer, sizeof(new->peeraddr)); 
    933935 
    934936                new->fd.fd  = sock; 
     
    938940                new->wpipe.fd = -1; 
    939941 
    940                 /* get remote endpoint addr */ 
    941                 sl = sizeof(struct sockaddr_in6); 
    942                 memset(&(new->peeraddr), 0, sl); 
    943                 getpeername(sock, (struct sockaddr *) &(new->peeraddr), &sl); 
    944  
    945942                /* get local endpoint addr */ 
    946943                sl = sizeof(struct sockaddr_in6); 
    947                 memset(&(new->servaddr), 0, sl); 
    948944                getsockname(sock, (struct sockaddr *) &(new->servaddr), &sl); 
    949945 
     
    989985        for (cur = uh_clients; cur; prv = cur, cur = cur->next) 
    990986        { 
    991                 if ((cur == cl) || (!cl && cur->dead)) 
     987                if (cur == cl) 
    992988                { 
    993989                        if (prv) 
  • trunk/package/uhttpd/src/uhttpd-utils.h

    r32651 r32704  
    116116struct listener * uh_listener_lookup(int sock); 
    117117 
    118 struct client * uh_client_add(int sock, struct listener *serv); 
     118struct client * uh_client_add(int sock, struct listener *serv, 
     119                              struct sockaddr_in6 *peer); 
     120 
    119121struct client * uh_client_lookup(int sock); 
    120122 
  • trunk/package/uhttpd/src/uhttpd.c

    r32651 r32704  
    3636 
    3737 
     38const char * http_methods[] = { "GET", "POST", "HEAD", }; 
     39const char * http_versions[] = { "HTTP/0.9", "HTTP/1.0", "HTTP/1.1", }; 
     40 
    3841static int run = 1; 
    3942 
     
    124127static void uh_listener_cb(struct uloop_fd *u, unsigned int events); 
    125128 
    126 static int uh_socket_bind(fd_set *serv_fds, int *max_fd, 
    127                                                   const char *host, const char *port, 
    128                                                   struct addrinfo *hints, int do_tls, 
    129                                                   struct config *conf) 
     129static int uh_socket_bind(const char *host, const char *port, 
     130                          struct addrinfo *hints, int do_tls, 
     131                          struct config *conf) 
    130132{ 
    131133        int sock = -1; 
     
    214216#endif 
    215217 
    216                 /* add socket to server fd set */ 
    217                 FD_SET(sock, serv_fds); 
     218                /* add socket to uloop */ 
    218219                fd_cloexec(sock); 
    219                 *max_fd = max(*max_fd, sock); 
    220  
    221220                uh_ufd_add(&l->fd, uh_listener_cb, ULOOP_READ); 
    222221 
     
    269268 
    270269                /* check method */ 
    271                 if (strcmp(method, "GET") && strcmp(method, "HEAD") && strcmp(method, "POST")) 
     270                if (method && !strcmp(method, "GET")) 
     271                        req->method = UH_HTTP_MSG_GET; 
     272                else if (method && !strcmp(method, "POST")) 
     273                        req->method = UH_HTTP_MSG_POST; 
     274                else if (method && !strcmp(method, "HEAD")) 
     275                        req->method = UH_HTTP_MSG_HEAD; 
     276                else 
    272277                { 
    273278                        /* invalid method */ 
     
    275280                        return NULL; 
    276281                } 
    277                 else 
    278                 { 
    279                         switch(method[0]) 
    280                         { 
    281                                 case 'G': 
    282                                         req->method = UH_HTTP_MSG_GET; 
    283                                         break; 
    284  
    285                                 case 'H': 
    286                                         req->method = UH_HTTP_MSG_HEAD; 
    287                                         break; 
    288  
    289                                 case 'P': 
    290                                         req->method = UH_HTTP_MSG_POST; 
    291                                         break; 
    292                         } 
    293                 } 
    294282 
    295283                /* check path */ 
     
    306294 
    307295                /* check version */ 
    308                 if ((version == NULL) || (strcmp(version, "HTTP/0.9") && 
    309                     strcmp(version, "HTTP/1.0") && strcmp(version, "HTTP/1.1"))) 
     296                if (version && !strcmp(version, "HTTP/0.9")) 
     297                        req->version = UH_HTTP_VER_0_9; 
     298                else if (version && !strcmp(version, "HTTP/1.0")) 
     299                        req->version = UH_HTTP_VER_1_0; 
     300                else if (version && !strcmp(version, "HTTP/1.1")) 
     301                        req->version = UH_HTTP_VER_1_1; 
     302                else 
    310303                { 
    311304                        /* unsupported version */ 
     
    313306                        return NULL; 
    314307                } 
    315                 else 
    316                 { 
    317                         req->version = strtof(&version[5], NULL); 
    318                 } 
    319  
    320                 D("SRV: %s %s HTTP/%.1f\n", 
    321                   (req->method == UH_HTTP_MSG_POST) ? "POST" : 
    322                         (req->method == UH_HTTP_MSG_GET) ? "GET" : "HEAD", 
    323                   req->url, req->version); 
     308 
     309                D("SRV: %s %s %s\n", 
     310                  http_methods[req->method], req->url, http_versions[req->version]); 
    324311 
    325312                /* process header fields */ 
     
    523510        struct config *conf; 
    524511 
     512        struct sockaddr_in6 sa; 
     513        socklen_t sl = sizeof(sa); 
     514 
    525515        serv = container_of(u, struct listener, fd); 
    526516        conf = serv->conf; 
     
    531521 
    532522        /* handle new connections */ 
    533         if ((new_fd = accept(u->fd, NULL, 0)) != -1) 
     523        if ((new_fd = accept(u->fd, (struct sockaddr *)&sa, &sl)) != -1) 
    534524        { 
    535525                D("SRV: Server(%d) accept => Client(%d)\n", u->fd, new_fd); 
    536526 
    537527                /* add to global client list */ 
    538                 if ((cl = uh_client_add(new_fd, serv)) != NULL) 
     528                if ((cl = uh_client_add(new_fd, serv, &sa)) != NULL) 
    539529                { 
    540530                        /* add client socket to global fdset */ 
     
    786776int main (int argc, char **argv) 
    787777{ 
    788         /* master file descriptor list */ 
    789         fd_set serv_fds; 
    790  
    791778        /* working structs */ 
    792779        struct addrinfo hints; 
     
    795782 
    796783        /* maximum file descriptor number */ 
    797         int cur_fd, max_fd = 0; 
     784        int cur_fd = 0; 
    798785 
    799786#ifdef HAVE_TLS 
     
    807794        /* args */ 
    808795        int opt; 
    809         char bind[128]; 
     796        char addr[128]; 
    810797        char *port = NULL; 
    811798 
    812 #ifdef HAVE_LUA 
     799#if defined(HAVE_LUA) || defined(HAVE_TLS) || defined(HAVE_UBUS) 
    813800        /* library handle */ 
    814801        void *lib; 
    815802#endif 
    816  
    817         FD_ZERO(&serv_fds); 
    818803 
    819804        /* handle SIGPIPE, SIGINT, SIGTERM */ 
     
    836821        /* parse args */ 
    837822        memset(&conf, 0, sizeof(conf)); 
    838         memset(bind, 0, sizeof(bind)); 
    839823 
    840824        uloop_init(); 
     
    848832                        case 'p': 
    849833                        case 's': 
     834                                memset(addr, 0, sizeof(addr)); 
     835 
    850836                                if ((port = strrchr(optarg, ':')) != NULL) 
    851837                                { 
    852838                                        if ((optarg[0] == '[') && (port > optarg) && (port[-1] == ']')) 
    853                                                 memcpy(bind, optarg + 1, 
    854                                                         min(sizeof(bind), (int)(port - optarg) - 2)); 
     839                                                memcpy(addr, optarg + 1, 
     840                                                        min(sizeof(addr), (int)(port - optarg) - 2)); 
    855841                                        else 
    856                                                 memcpy(bind, optarg, 
    857                                                         min(sizeof(bind), (int)(port - optarg))); 
     842                                                memcpy(addr, optarg, 
     843                                                        min(sizeof(addr), (int)(port - optarg))); 
    858844 
    859845                                        port++; 
     
    881867 
    882868                                /* bind sockets */ 
    883                                 bound += uh_socket_bind(&serv_fds, &max_fd, 
    884                                                                                 bind[0] ? bind : NULL, 
    885                                                                                 port, &hints, (opt == 's'), &conf); 
    886  
    887                                 memset(bind, 0, sizeof(bind)); 
     869                                bound += uh_socket_bind(addr[0] ? addr : NULL, port, &hints, 
     870                                                        (opt == 's'), &conf); 
    888871                                break; 
    889872 
     
    920903 
    921904                                break; 
     905#else 
     906                        case 'C': 
     907                        case 'K': 
     908                                fprintf(stderr, 
     909                                        "Notice: TLS support not compiled, ignoring -%c\n", 
     910                                        opt); 
     911                                break; 
    922912#endif 
    923913 
     
    992982                                } 
    993983                                break; 
     984#else 
     985                        case 'x': 
     986                        case 'i': 
     987                                fprintf(stderr, 
     988                                        "Notice: CGI support not compiled, ignoring -%c\n", 
     989                                        opt); 
     990                                break; 
    994991#endif 
    995992 
     
    10041001                                conf.lua_handler = optarg; 
    10051002                                break; 
     1003#else 
     1004                        case 'l': 
     1005                        case 'L': 
     1006                                fprintf(stderr, 
     1007                                        "Notice: Lua support not compiled, ignoring -%c\n", 
     1008                                        opt); 
     1009                                break; 
    10061010#endif 
    10071011 
     
    10151019                        case 'U': 
    10161020                                conf.ubus_socket = optarg; 
     1021                                break; 
     1022#else 
     1023                        case 'u': 
     1024                        case 'U': 
     1025                                fprintf(stderr, 
     1026                                        "Notice: UBUS support not compiled, ignoring -%c\n", 
     1027                                        opt); 
    10171028                                break; 
    10181029#endif 
  • trunk/package/uhttpd/src/uhttpd.h

    r32651 r32704  
    6464#define UH_LIMIT_MSGHEAD        4096 
    6565#define UH_LIMIT_HEADERS        64 
    66  
    6766#define UH_LIMIT_CLIENTS        64 
    6867 
    69 #define UH_HTTP_MSG_GET         0 
    70 #define UH_HTTP_MSG_HEAD        1 
    71 #define UH_HTTP_MSG_POST        2 
    72  
    73 #define UH_SOCK_CLIENT          0 
    74 #define UH_SOCK_SERVER          1 
    7568 
    7669struct listener; 
     
    129122}; 
    130123 
     124enum http_method { 
     125        UH_HTTP_MSG_GET, 
     126        UH_HTTP_MSG_POST, 
     127        UH_HTTP_MSG_HEAD, 
     128}; 
     129 
     130extern const char *http_methods[]; 
     131 
     132enum http_version { 
     133        UH_HTTP_VER_0_9, 
     134        UH_HTTP_VER_1_0, 
     135        UH_HTTP_VER_1_1, 
     136}; 
     137 
     138extern const char *http_versions[]; 
     139 
    131140struct http_request { 
    132         int     method; 
    133         float version; 
     141        enum http_method method; 
     142        enum http_version version; 
    134143        int redirect_status; 
    135144        char *url; 
     
    168177        void *priv; 
    169178        bool dispatched; 
    170         bool dead; 
    171179        struct { 
    172180                char buf[UH_LIMIT_MSGHEAD]; 
Note: See TracChangeset for help on using the changeset viewer.