Changeset 32651


Ignore:
Timestamp:
2012-07-09T02:08:20+02:00 (6 years ago)
Author:
jow
Message:

[package] uhttpd: various fixes

  • avoid closing descriptors before removing them from uloop (#11755, #11830)
  • do not auto-initialize ubus if no prefix is set (#11832)
  • remove extraneous client context pointer from cgi and lua states
  • code cleanups and debug message changes
Location:
trunk/package/uhttpd
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/uhttpd/Makefile

    r32640 r32651  
    99 
    1010PKG_NAME:=uhttpd 
    11 PKG_RELEASE:=37 
     11PKG_RELEASE:=38 
    1212 
    1313PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
  • trunk/package/uhttpd/src/uhttpd-cgi.c

    r32640 r32651  
    129129static void uh_cgi_shutdown(struct uh_cgi_state *state) 
    130130{ 
    131         close(state->rfd); 
    132         close(state->wfd); 
    133131        free(state); 
    134132} 
     
    140138 
    141139        struct uh_cgi_state *state = (struct uh_cgi_state *)cl->priv; 
    142         struct http_response *res = &state->cl->response; 
    143         struct http_request *req = &state->cl->request; 
     140        struct http_response *res = &cl->response; 
     141        struct http_request *req = &cl->request; 
    144142 
    145143        /* there is unread post data waiting */ 
     
    147145        { 
    148146                /* remaining data in http head buffer ... */ 
    149                 if (state->cl->httpbuf.len > 0) 
    150                 { 
    151                         len = min(state->content_length, state->cl->httpbuf.len); 
    152  
    153                         D("CGI: Child(%d) feed %d HTTP buffer bytes\n", 
    154                           state->cl->proc.pid, len); 
    155  
    156                         memcpy(buf, state->cl->httpbuf.ptr, len); 
    157  
    158                         state->cl->httpbuf.len -= len; 
    159                         state->cl->httpbuf.ptr +=len; 
     147                if (cl->httpbuf.len > 0) 
     148                { 
     149                        len = min(state->content_length, cl->httpbuf.len); 
     150 
     151                        D("CGI: Child(%d) feed %d HTTP buffer bytes\n", cl->proc.pid, len); 
     152 
     153                        memcpy(buf, cl->httpbuf.ptr, len); 
     154 
     155                        cl->httpbuf.len -= len; 
     156                        cl->httpbuf.ptr +=len; 
    160157                } 
    161158 
     
    163160                else 
    164161                { 
    165                         len = uh_tcp_recv(state->cl, buf, 
     162                        len = uh_tcp_recv(cl, buf, 
    166163                                                          min(state->content_length, sizeof(buf))); 
    167164 
     
    170167 
    171168                        D("CGI: Child(%d) feed %d/%d TCP socket bytes\n", 
    172                           state->cl->proc.pid, len, 
    173                           min(state->content_length, sizeof(buf))); 
     169                          cl->proc.pid, len, min(state->content_length, sizeof(buf))); 
    174170                } 
    175171 
     
    180176 
    181177                /* ... write to CGI process */ 
    182                 len = uh_raw_send(state->wfd, buf, len, 
     178                len = uh_raw_send(cl->wpipe.fd, buf, len, 
    183179                                                  cl->server->conf->script_timeout); 
    184180 
    185181                /* explicit EOF notification for the child */ 
    186182                if (state->content_length <= 0) 
    187                         close(state->wfd); 
     183                        uh_ufd_remove(&cl->wpipe); 
    188184        } 
    189185 
    190186        /* try to read data from child */ 
    191         while ((len = uh_raw_recv(state->rfd, buf, sizeof(buf), -1)) > 0) 
     187        while ((len = uh_raw_recv(cl->rpipe.fd, buf, sizeof(buf), -1)) > 0) 
    192188        { 
    193189                /* we have not pushed out headers yet, parse input */ 
     
    200196                        { 
    201197                                /* write status */ 
    202                                 ensure_out(uh_http_sendf(state->cl, NULL, 
     198                                ensure_out(uh_http_sendf(cl, NULL, 
    203199                                        "HTTP/%.1f %03d %s\r\n" 
    204200                                        "Connection: close\r\n", 
     
    209205                                        !uh_cgi_header_lookup(res, "Content-Type")) 
    210206                                { 
    211                                         ensure_out(uh_http_send(state->cl, NULL, 
     207                                        ensure_out(uh_http_send(cl, NULL, 
    212208                                                "Content-Type: text/plain\r\n", -1)); 
    213209                                } 
     
    217213                                        !uh_cgi_header_lookup(res, "Transfer-Encoding")) 
    218214                                { 
    219                                         ensure_out(uh_http_send(state->cl, NULL, 
     215                                        ensure_out(uh_http_send(cl, NULL, 
    220216                                                "Transfer-Encoding: chunked\r\n", -1)); 
    221217                                } 
     
    224220                                foreach_header(i, res->headers) 
    225221                                { 
    226                                         ensure_out(uh_http_sendf(state->cl, NULL, "%s: %s\r\n", 
     222                                        ensure_out(uh_http_sendf(cl, NULL, "%s: %s\r\n", 
    227223                                                res->headers[i], res->headers[i+1])); 
    228224                                } 
    229225 
    230226                                /* terminate header */ 
    231                                 ensure_out(uh_http_send(state->cl, NULL, "\r\n", -1)); 
     227                                ensure_out(uh_http_send(cl, NULL, "\r\n", -1)); 
    232228 
    233229                                state->header_sent = true; 
     
    237233                                { 
    238234                                        D("CGI: Child(%d) relaying %d rest bytes\n", 
    239                                           state->cl->proc.pid, len - hdroff); 
    240  
    241                                         ensure_out(uh_http_send(state->cl, req, 
     235                                          cl->proc.pid, len - hdroff); 
     236 
     237                                        ensure_out(uh_http_send(cl, req, 
    242238                                                                                        &buf[hdroff], len - hdroff)); 
    243239                                } 
     
    258254                                 */ 
    259255 
    260                                 ensure_out(uh_http_sendf(state->cl, NULL, 
     256                                ensure_out(uh_http_sendf(cl, NULL, 
    261257                                                                                 "HTTP/%.1f 200 OK\r\n" 
    262258                                                                                 "Content-Type: text/plain\r\n" 
     
    269265 
    270266                                D("CGI: Child(%d) relaying %d invalid bytes\n", 
    271                                   state->cl->proc.pid, len); 
    272  
    273                                 ensure_out(uh_http_send(state->cl, req, buf, len)); 
     267                                  cl->proc.pid, len); 
     268 
     269                                ensure_out(uh_http_send(cl, req, buf, len)); 
    274270                        } 
    275271                } 
     
    277273                { 
    278274                        /* headers complete, pass through buffer to socket */ 
    279                         D("CGI: Child(%d) relaying %d normal bytes\n", 
    280                           state->cl->proc.pid, len); 
    281  
    282                         ensure_out(uh_http_send(state->cl, req, buf, len)); 
     275                        D("CGI: Child(%d) relaying %d normal bytes\n", cl->proc.pid, len); 
     276                        ensure_out(uh_http_send(cl, req, buf, len)); 
    283277                } 
    284278        } 
     
    288282                ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (len == -1))) 
    289283        { 
    290                 D("CGI: Child(%d) presumed dead [%s]\n", 
    291                   state->cl->proc.pid, strerror(errno)); 
     284                D("CGI: Child(%d) presumed dead [%s]\n", cl->proc.pid, strerror(errno)); 
    292285 
    293286                goto out; 
     
    299292        if (!state->header_sent) 
    300293        { 
    301                 if (state->cl->timeout.pending) 
    302                         uh_http_sendhf(state->cl, 502, "Bad Gateway", 
     294                if (cl->timeout.pending) 
     295                        uh_http_sendhf(cl, 502, "Bad Gateway", 
    303296                                                   "The CGI process did not produce any response\n"); 
    304297                else 
    305                         uh_http_sendhf(state->cl, 504, "Gateway Timeout", 
     298                        uh_http_sendhf(cl, 504, "Gateway Timeout", 
    306299                                                   "The CGI process took too long to produce a " 
    307300                                                   "response\n"); 
     
    309302        else 
    310303        { 
    311                 uh_http_send(state->cl, req, "", 0); 
     304                uh_http_send(cl, req, "", 0); 
    312305        } 
    313306 
     
    530523                memset(state, 0, sizeof(*state)); 
    531524 
    532                 state->cl = cl; 
    533                 state->cl->pipe.fd = rfd[0]; 
    534                 state->cl->proc.pid = child; 
     525                cl->rpipe.fd = rfd[0]; 
     526                cl->wpipe.fd = wfd[1]; 
     527                cl->proc.pid = child; 
     528 
     529                /* make pipe non-blocking */ 
     530                fd_nonblock(cl->rpipe.fd); 
     531                fd_nonblock(cl->wpipe.fd); 
    535532 
    536533                /* close unneeded pipe ends */ 
     
    555552                } 
    556553 
    557                 state->rfd = rfd[0]; 
    558                 fd_nonblock(state->rfd); 
    559  
    560                 state->wfd = wfd[1]; 
    561                 fd_nonblock(state->wfd); 
    562  
    563554                cl->cb = uh_cgi_socket_cb; 
    564555                cl->priv = state; 
  • trunk/package/uhttpd/src/uhttpd-cgi.h

    r31931 r32651  
    2929 
    3030struct uh_cgi_state { 
    31         int rfd; 
    32         int wfd; 
    33         struct client *cl; 
    3431        char httpbuf[UH_LIMIT_MSGHEAD]; 
    3532        int content_length; 
  • trunk/package/uhttpd/src/uhttpd-lua.c

    r32640 r32651  
    251251static void uh_lua_shutdown(struct uh_lua_state *state) 
    252252{ 
    253         close(state->rfd); 
    254         close(state->wfd); 
    255253        free(state); 
    256254} 
     
    267265        { 
    268266                /* remaining data in http head buffer ... */ 
    269                 if (state->cl->httpbuf.len > 0) 
    270                 { 
    271                         len = min(state->content_length, state->cl->httpbuf.len); 
    272  
    273                         D("Lua: Child(%d) feed %d HTTP buffer bytes\n", 
    274                           state->cl->proc.pid, len); 
    275  
    276                         memcpy(buf, state->cl->httpbuf.ptr, len); 
    277  
    278                         state->cl->httpbuf.len -= len; 
    279                         state->cl->httpbuf.ptr += len; 
     267                if (cl->httpbuf.len > 0) 
     268                { 
     269                        len = min(state->content_length, cl->httpbuf.len); 
     270 
     271                        D("Lua: Child(%d) feed %d HTTP buffer bytes\n", cl->proc.pid, len); 
     272 
     273                        memcpy(buf, cl->httpbuf.ptr, len); 
     274 
     275                        cl->httpbuf.len -= len; 
     276                        cl->httpbuf.ptr += len; 
    280277                } 
    281278 
     
    283280                else 
    284281                { 
    285                         len = uh_tcp_recv(state->cl, buf, 
    286                                                           min(state->content_length, sizeof(buf))); 
     282                        len = uh_tcp_recv(cl, buf, min(state->content_length, sizeof(buf))); 
    287283 
    288284                        if ((len < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))) 
     
    290286 
    291287                        D("Lua: Child(%d) feed %d/%d TCP socket bytes\n", 
    292                           state->cl->proc.pid, len, 
    293                           min(state->content_length, sizeof(buf))); 
     288                          cl->proc.pid, len, min(state->content_length, sizeof(buf))); 
    294289                } 
    295290 
     
    300295 
    301296                /* ... write to Lua process */ 
    302                 len = uh_raw_send(state->wfd, buf, len, 
     297                len = uh_raw_send(cl->wpipe.fd, buf, len, 
    303298                                                  cl->server->conf->script_timeout); 
    304299 
    305300                /* explicit EOF notification for the child */ 
    306301                if (state->content_length <= 0) 
    307                         close(state->wfd); 
     302                        uh_ufd_remove(&cl->wpipe); 
    308303        } 
    309304 
    310305        /* try to read data from child */ 
    311         while ((len = uh_raw_recv(state->rfd, buf, sizeof(buf), -1)) > 0) 
     306        while ((len = uh_raw_recv(cl->rpipe.fd, buf, sizeof(buf), -1)) > 0) 
    312307        { 
    313308                /* pass through buffer to socket */ 
    314                 D("Lua: Child(%d) relaying %d normal bytes\n", state->cl->proc.pid, len); 
    315                 ensure_out(uh_tcp_send(state->cl, buf, len)); 
     309                D("Lua: Child(%d) relaying %d normal bytes\n", cl->proc.pid, len); 
     310                ensure_out(uh_tcp_send(cl, buf, len)); 
    316311                state->data_sent = true; 
    317312        } 
     
    322317        { 
    323318                D("Lua: Child(%d) presumed dead [%s]\n", 
    324                   state->cl->proc.pid, strerror(errno)); 
     319                  cl->proc.pid, strerror(errno)); 
    325320 
    326321                goto out; 
     
    332327        if (!state->data_sent) 
    333328        { 
    334                 if (state->cl->timeout.pending) 
    335                         uh_http_sendhf(state->cl, 502, "Bad Gateway", 
     329                if (cl->timeout.pending) 
     330                        uh_http_sendhf(cl, 502, "Bad Gateway", 
    336331                                                   "The Lua process did not produce any response\n"); 
    337332                else 
    338                         uh_http_sendhf(state->cl, 504, "Gateway Timeout", 
     333                        uh_http_sendhf(cl, 504, "Gateway Timeout", 
    339334                                                   "The Lua process took too long to produce a " 
    340335                                                   "response\n"); 
     
    558553                memset(state, 0, sizeof(*state)); 
    559554 
    560                 state->cl = cl; 
    561                 state->cl->pipe.fd = rfd[0]; 
    562                 state->cl->proc.pid = child; 
     555                cl->rpipe.fd = rfd[0]; 
     556                cl->wpipe.fd = wfd[1]; 
     557                cl->proc.pid = child; 
     558 
     559                /* make pipe non-blocking */ 
     560                fd_nonblock(cl->rpipe.fd); 
     561                fd_nonblock(cl->wpipe.fd); 
    563562 
    564563                /* close unneeded pipe ends */ 
     
    583582                } 
    584583 
    585                 state->rfd = rfd[0]; 
    586                 fd_nonblock(state->rfd); 
    587  
    588                 state->wfd = wfd[1]; 
    589                 fd_nonblock(state->wfd); 
    590  
    591584                cl->cb = uh_lua_socket_cb; 
    592585                cl->priv = state; 
  • trunk/package/uhttpd/src/uhttpd-lua.h

    r31931 r32651  
    3434 
    3535struct uh_lua_state { 
    36         int rfd; 
    37         int wfd; 
    38         struct client *cl; 
    3936        char httpbuf[UH_LIMIT_MSGHEAD]; 
    4037        int content_length; 
  • trunk/package/uhttpd/src/uhttpd-utils.c

    r32640 r32651  
    120120                                                 NULL, &timeout)) < 0) && (errno == EINTR)) 
    121121        { 
    122                 D("IO: Socket(%d) select interrupted: %s\n", 
     122                D("IO: FD(%d) select interrupted: %s\n", 
    123123                                fd, strerror(errno)); 
    124124 
     
    128128        if (rv <= 0) 
    129129        { 
    130                 D("IO: Socket(%d) appears dead (rv=%d)\n", fd, rv); 
     130                D("IO: FD(%d) appears dead (rv=%d)\n", fd, rv); 
    131131                return false; 
    132132        } 
     
    147147                        if (errno == EINTR) 
    148148                        { 
    149                                 D("IO: Socket(%d) interrupted\n", cl->fd.fd); 
     149                                D("IO: FD(%d) interrupted\n", cl->fd.fd); 
    150150                                continue; 
    151151                        } 
     
    157157                        else 
    158158                        { 
    159                                 D("IO: Socket(%d) write error: %s\n", fd, strerror(errno)); 
     159                                D("IO: FD(%d) write error: %s\n", fd, strerror(errno)); 
    160160                                return -1; 
    161161                        } 
     
    169169                else if (rv == 0) 
    170170                { 
    171                         D("IO: Socket(%d) closed\n", fd); 
     171                        D("IO: FD(%d) appears closed\n", fd); 
    172172                        return 0; 
    173173                } 
    174174                else if (rv < len) 
    175175                { 
    176                         D("IO: Socket(%d) short write %d/%d bytes\n", fd, rv, len); 
     176                        D("IO: FD(%d) short write %d/%d bytes\n", fd, rv, len); 
    177177                        len -= rv; 
    178178                        buf += rv; 
     
    181181                else 
    182182                { 
    183                         D("IO: Socket(%d) sent %d/%d bytes\n", fd, rv, len); 
     183                        D("IO: FD(%d) sent %d/%d bytes\n", fd, rv, len); 
    184184                        return rv; 
    185185                } 
     
    231231                        else 
    232232                        { 
    233                                 D("IO: Socket(%d) read error: %s\n", fd, strerror(errno)); 
     233                                D("IO: FD(%d) read error: %s\n", fd, strerror(errno)); 
    234234                                return -1; 
    235235                        } 
     
    237237                else if (rv == 0) 
    238238                { 
    239                         D("IO: Socket(%d) closed\n", fd); 
     239                        D("IO: FD(%d) appears closed\n", fd); 
    240240                        return 0; 
    241241                } 
    242242                else 
    243243                { 
    244                         D("IO: Socket(%d) read %d bytes\n", fd, rv); 
     244                        D("IO: FD(%d) read %d bytes\n", fd, rv); 
    245245                        return rv; 
    246246                } 
     
    935935                new->server = serv; 
    936936 
     937                new->rpipe.fd = -1; 
     938                new->wpipe.fd = -1; 
     939 
    937940                /* get remote endpoint addr */ 
    938941                sl = sizeof(struct sockaddr_in6); 
     
    949952 
    950953                serv->n_clients++; 
     954 
     955                D("IO: Client(%d) allocated\n", new->fd.fd); 
    951956        } 
    952957 
     
    9971002                                uloop_process_delete(&cur->proc); 
    9981003 
    999                         if (cur->pipe.fd) 
    1000                                 uloop_fd_delete(&cur->pipe); 
    1001  
    1002                         uloop_fd_delete(&cur->fd); 
    1003                         close(cur->fd.fd); 
    1004  
    1005                         D("IO: Socket(%d) closing\n", cur->fd.fd); 
     1004                        D("IO: Client(%d) freeing\n", cur->fd.fd); 
     1005 
     1006                        uh_ufd_remove(&cur->rpipe); 
     1007                        uh_ufd_remove(&cur->wpipe); 
     1008                        uh_ufd_remove(&cur->fd); 
     1009 
    10061010                        cur->server->n_clients--; 
    10071011 
     
    10131017 
    10141018 
     1019void uh_ufd_add(struct uloop_fd *u, uloop_fd_handler h, unsigned int ev) 
     1020{ 
     1021        if (h != NULL) 
     1022        { 
     1023                u->cb = h; 
     1024                uloop_fd_add(u, ev); 
     1025                D("IO: FD(%d) added to uloop\n", u->fd); 
     1026        } 
     1027} 
     1028 
     1029void uh_ufd_remove(struct uloop_fd *u) 
     1030{ 
     1031        if (u->cb != NULL) 
     1032        { 
     1033                uloop_fd_delete(u); 
     1034                D("IO: FD(%d) removed from uloop\n", u->fd); 
     1035                u->cb = NULL; 
     1036        } 
     1037 
     1038        if (u->fd > -1) 
     1039        { 
     1040                close(u->fd); 
     1041                D("IO: FD(%d) closed\n", u->fd); 
     1042                u->fd = -1; 
     1043        } 
     1044} 
     1045 
     1046 
    10151047#ifdef HAVE_CGI 
    10161048static struct interpreter *uh_interpreters = NULL; 
  • trunk/package/uhttpd/src/uhttpd-utils.h

    r31931 r32651  
    2323#include <pwd.h> 
    2424#include <sys/stat.h> 
     25 
     26#include <libubox/uloop.h> 
     27 
    2528 
    2629#ifdef HAVE_SHADOW 
     
    124127void uh_client_remove(struct client *cl); 
    125128 
    126 #define uh_client_gc() uh_client_remove(NULL) 
     129void uh_ufd_add(struct uloop_fd *u, uloop_fd_handler h, unsigned int ev); 
     130void uh_ufd_remove(struct uloop_fd *u); 
    127131 
    128132 
  • trunk/package/uhttpd/src/uhttpd.c

    r32644 r32651  
    219219                *max_fd = max(*max_fd, sock); 
    220220 
    221                 l->fd.cb = uh_listener_cb; 
    222                 uloop_fd_add(&l->fd, ULOOP_READ); 
     221                uh_ufd_add(&l->fd, uh_listener_cb, ULOOP_READ); 
    223222 
    224223                bound++; 
     
    515514} 
    516515 
    517 static void uh_client_cb(struct uloop_fd *u, unsigned int events); 
     516static void uh_socket_cb(struct uloop_fd *u, unsigned int events); 
    518517 
    519518static void uh_listener_cb(struct uloop_fd *u, unsigned int events) 
     
    540539                { 
    541540                        /* add client socket to global fdset */ 
    542                         uloop_fd_add(&cl->fd, ULOOP_READ); 
     541                        uh_ufd_add(&cl->fd, uh_socket_cb, ULOOP_READ); 
     542                        fd_cloexec(cl->fd.fd); 
    543543 
    544544#ifdef HAVE_TLS 
     
    556556                        } 
    557557#endif 
    558  
    559                         cl->fd.cb = uh_client_cb; 
    560                         fd_cloexec(new_fd); 
    561558                } 
    562559 
     
    570567} 
    571568 
    572 static void uh_pipe_cb(struct uloop_fd *u, unsigned int events) 
    573 { 
    574         struct client *cl = container_of(u, struct client, pipe); 
    575  
    576         if (!u->error) 
    577         { 
    578                 D("SRV: Client(%d) pipe(%d) readable\n", 
    579                   cl->fd.fd, cl->pipe.fd); 
    580  
    581                 uh_client_cb(&cl->fd, ULOOP_WRITE); 
    582         } 
     569static void uh_client_cb(struct client *cl, unsigned int events); 
     570 
     571static void uh_rpipe_cb(struct uloop_fd *u, unsigned int events) 
     572{ 
     573        struct client *cl = container_of(u, struct client, rpipe); 
     574 
     575        D("SRV: Client(%d) rpipe readable\n", cl->fd.fd); 
     576 
     577        uh_client_cb(cl, ULOOP_WRITE); 
     578} 
     579 
     580static void uh_socket_cb(struct uloop_fd *u, unsigned int events) 
     581{ 
     582        struct client *cl = container_of(u, struct client, fd); 
     583 
     584        D("SRV: Client(%d) socket readable\n", cl->fd.fd); 
     585 
     586        uh_client_cb(cl, ULOOP_READ); 
    583587} 
    584588 
     
    587591        struct client *cl = container_of(p, struct client, proc); 
    588592 
    589         D("SRV: Client(%d) child(%d) is dead\n", cl->fd.fd, cl->proc.pid); 
    590  
    591         cl->dead = true; 
    592         cl->fd.eof = true; 
    593         uh_client_cb(&cl->fd, ULOOP_READ | ULOOP_WRITE); 
     593        D("SRV: Client(%d) child(%d) dead\n", cl->fd.fd, cl->proc.pid); 
     594 
     595        uh_client_cb(cl, ULOOP_READ | ULOOP_WRITE); 
    594596} 
    595597 
     
    625627} 
    626628 
    627 static void uh_client_cb(struct uloop_fd *u, unsigned int events) 
     629static void uh_client_cb(struct client *cl, unsigned int events) 
    628630{ 
    629631        int i; 
    630         struct client *cl; 
    631632        struct config *conf; 
    632633        struct http_request *req; 
    633634 
    634         cl = container_of(u, struct client, fd); 
    635635        conf = cl->server->conf; 
    636636 
    637         D("SRV: Client(%d) enter callback\n", u->fd); 
     637        D("SRV: Client(%d) enter callback\n", cl->fd.fd); 
    638638 
    639639        /* undispatched yet */ 
     
    643643                if (!(events & ULOOP_READ)) 
    644644                { 
    645                         D("SRV: Client(%d) ignoring write event before headers\n", u->fd); 
     645                        D("SRV: Client(%d) ignoring write event before headers\n", cl->fd.fd); 
    646646                        return; 
    647647                } 
     
    650650                if (!(req = uh_http_header_recv(cl))) 
    651651                { 
    652                         D("SRV: Client(%d) failed to receive header\n", u->fd); 
     652                        D("SRV: Client(%d) failed to receive header\n", cl->fd.fd); 
    653653                        uh_client_shutdown(cl); 
    654654                        return; 
     
    664664                        { 
    665665                                D("SRV: Client(%d) unknown expect header (%s)\n", 
    666                                   u->fd, req->headers[i+1]); 
     666                                  cl->fd.fd, req->headers[i+1]); 
    667667 
    668668                                uh_http_response(cl, 417, "Precondition Failed"); 
     
    672672                        else 
    673673                        { 
    674                                 D("SRV: Client(%d) sending HTTP/1.1 100 Continue\n", u->fd); 
     674                                D("SRV: Client(%d) sending HTTP/1.1 100 Continue\n", cl->fd.fd); 
    675675 
    676676                                uh_http_sendf(cl, NULL, "HTTP/1.1 100 Continue\r\n\r\n"); 
     
    695695                if (!uh_dispatch_request(cl, req)) 
    696696                { 
    697                         D("SRV: Client(%d) failed to dispach request\n", u->fd); 
     697                        D("SRV: Client(%d) failed to dispach request\n", cl->fd.fd); 
    698698                        uh_client_shutdown(cl); 
    699699                        return; 
     
    701701 
    702702                /* request handler spawned a pipe, register handler */ 
    703                 if (cl->pipe.fd) 
    704                 { 
    705                         D("SRV: Client(%d) pipe(%d) spawned\n", u->fd, cl->pipe.fd); 
    706  
    707                         cl->pipe.cb = uh_pipe_cb; 
    708                         uloop_fd_add(&cl->pipe, ULOOP_READ); 
     703                if (cl->rpipe.fd > -1) 
     704                { 
     705                        D("SRV: Client(%d) pipe(%d) spawned\n", cl->fd.fd, cl->rpipe.fd); 
     706 
     707                        uh_ufd_add(&cl->rpipe, uh_rpipe_cb, ULOOP_READ); 
    709708                } 
    710709 
     
    712711                if (cl->proc.pid) 
    713712                { 
    714                         D("SRV: Client(%d) child(%d) spawned\n", u->fd, cl->proc.pid); 
     713                        D("SRV: Client(%d) child(%d) spawned\n", cl->fd.fd, cl->proc.pid); 
    715714 
    716715                        cl->proc.cb = uh_child_cb; 
     
    722721 
    723722                /* header processing complete */ 
    724                 D("SRV: Client(%d) dispatched\n", u->fd); 
     723                D("SRV: Client(%d) dispatched\n", cl->fd.fd); 
    725724                cl->dispatched = true; 
    726725        } 
     
    728727        if (!cl->cb(cl)) 
    729728        { 
    730                 D("SRV: Client(%d) response callback signalized EOF\n", u->fd); 
     729                D("SRV: Client(%d) response callback signalized EOF\n", cl->fd.fd); 
    731730                uh_client_shutdown(cl); 
    732731                return; 
     
    10991098#endif 
    11001099#ifdef HAVE_UBUS 
    1101                                         "       -u string       URL prefix for HTTP/JSON handler, default is '/ubus'\n" 
     1100                                        "       -u string       URL prefix for HTTP/JSON handler\n" 
    11021101                                        "       -U file         Override ubus socket path\n" 
    11031102#endif 
     
    12111210                                "(Reason: %s)\n", dlerror()); 
    12121211        } 
    1213         else 
     1212        else if (conf.ubus_prefix) 
    12141213        { 
    12151214                /* resolve functions */ 
     
    12251224                } 
    12261225 
    1227                 /* default ubus prefix */ 
    1228                 if (!conf.ubus_prefix) 
    1229                         conf.ubus_prefix = "/ubus"; 
    1230  
     1226                /* initialize ubus */ 
    12311227                conf.ubus_state = conf.ubus_init(&conf); 
    12321228        } 
  • trunk/package/uhttpd/src/uhttpd.h

    r32640 r32651  
    161161#endif 
    162162        struct uloop_fd fd; 
    163         struct uloop_fd pipe; 
     163        struct uloop_fd rpipe; 
     164        struct uloop_fd wpipe; 
    164165        struct uloop_process proc; 
    165166        struct uloop_timeout timeout; 
Note: See TracChangeset for help on using the changeset viewer.