Changeset 31572


Ignore:
Timestamp:
2012-05-03T19:19:22+02:00 (6 years ago)
Author:
jow
Message:

[package] uhttpd: display errors in init script, code formatting changes, bump package version

Location:
trunk/package/uhttpd
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/uhttpd/Makefile

    r30806 r31572  
    99 
    1010PKG_NAME:=uhttpd 
    11 PKG_RELEASE:=31 
     11PKG_RELEASE:=32 
    1212 
    1313PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
  • trunk/package/uhttpd/files/uhttpd.init

    r28841 r31572  
    109109        SERVICE_PID_FILE=/var/run/uhttpd_${cfg}.pid 
    110110        service_start $UHTTPD_BIN -f $UHTTPD_ARGS 
     111 
     112        # Check if daemon is running, if not then 
     113        # re-execute in foreground to display error. 
     114        sleep 1 && service_check $UHTTPD_BIN || \ 
     115                $UHTTPD_BIN -f $UHTTPD_ARGS 
    111116} 
    112117 
  • trunk/package/uhttpd/src/uhttpd-cgi.c

    r28257 r31572  
    3131 
    3232 
    33         if( ((bufptr = strfind(buf, len, "\r\n\r\n", 4)) != NULL) || 
    34             ((bufptr = strfind(buf, len, "\n\n", 2)) != NULL) 
    35         ) { 
     33        if (((bufptr = strfind(buf, len, "\r\n\r\n", 4)) != NULL) || 
     34            ((bufptr = strfind(buf, len, "\n\n", 2)) != NULL)) 
     35        { 
    3636                *off = (int)(bufptr - buf) + ((bufptr[0] == '\r') ? 4 : 2); 
    3737 
     
    4343                bufptr = &buf[0]; 
    4444 
    45                 for( pos = 0; pos < *off; pos++ ) 
     45                for (pos = 0; pos < *off; pos++) 
    4646                { 
    47                         if( !hdrname && (buf[pos] == ':') ) 
     47                        if (!hdrname && (buf[pos] == ':')) 
    4848                        { 
    4949                                buf[pos++] = 0; 
    5050 
    51                                 if( (pos < len) && (buf[pos] == ' ') ) 
     51                                if ((pos < len) && (buf[pos] == ' ')) 
    5252                                        pos++; 
    5353 
    54                                 if( pos < len ) 
     54                                if (pos < len) 
    5555                                { 
    5656                                        hdrname = bufptr; 
     
    5959                        } 
    6060 
    61                         else if( (buf[pos] == '\r') || (buf[pos] == '\n') ) 
     61                        else if ((buf[pos] == '\r') || (buf[pos] == '\n')) 
    6262                        { 
    63                                 if( ! hdrname ) 
     63                                if (! hdrname) 
    6464                                        break; 
    6565 
    6666                                buf[pos++] = 0; 
    6767 
    68                                 if( (pos < len) && (buf[pos] == '\n') ) 
     68                                if ((pos < len) && (buf[pos] == '\n')) 
    6969                                        pos++; 
    7070 
    71                                 if( pos <= len ) 
    72                                 { 
    73                                         if( (hdrcount + 1) < array_size(res.headers) ) 
     71                                if (pos <= len) 
     72                                { 
     73                                        if ((hdrcount + 1) < array_size(res.headers)) 
    7474                                        { 
    75                                                 if( ! strcasecmp(hdrname, "Status") ) 
     75                                                if (!strcasecmp(hdrname, "Status")) 
    7676                                                { 
    7777                                                        res.statuscode = atoi(bufptr); 
    7878 
    79                                                         if( res.statuscode < 100 ) 
     79                                                        if (res.statuscode < 100) 
    8080                                                                res.statuscode = 200; 
    8181 
    82                                                         if( ((bufptr = strchr(bufptr, ' ')) != NULL) && (&bufptr[1] != 0) ) 
     82                                                        if (((bufptr = strchr(bufptr, ' ')) != NULL) && 
     83                                                                (&bufptr[1] != 0)) 
     84                                                        { 
    8385                                                                res.statusmsg = &bufptr[1]; 
     86                                                        } 
    8487                                                } 
    8588                                                else 
     
    106109} 
    107110 
    108 static char * uh_cgi_header_lookup(struct http_response *res, const char *hdrname) 
     111static char * uh_cgi_header_lookup(struct http_response *res, 
     112                                                                   const char *hdrname) 
    109113{ 
    110114        int i; 
     
    112116        foreach_header(i, res->headers) 
    113117        { 
    114                 if( ! strcasecmp(res->headers[i], hdrname) ) 
     118                if (!strcasecmp(res->headers[i], hdrname)) 
    115119                        return res->headers[i+1]; 
    116120        } 
     
    119123} 
    120124 
    121 static int uh_cgi_error_500(struct client *cl, struct http_request *req, const char *message) 
     125static int uh_cgi_error_500(struct client *cl, struct http_request *req, 
     126                                                        const char *message) 
    122127{ 
    123         if( uh_http_sendf(cl, NULL, 
    124                 "HTTP/%.1f 500 Internal Server Error\r\n" 
    125                 "Content-Type: text/plain\r\n%s\r\n", 
    126                         req->version,  
    127                         (req->version > 1.0) 
    128                                 ? "Transfer-Encoding: chunked\r\n" : "" 
    129                 ) >= 0 
    130         ) { 
     128        if (uh_http_sendf(cl, NULL, 
     129                                          "HTTP/%.1f 500 Internal Server Error\r\n" 
     130                                          "Content-Type: text/plain\r\n%s\r\n", 
     131                                          req->version, 
     132                                          (req->version > 1.0) 
     133                                              ? "Transfer-Encoding: chunked\r\n" : "") >= 0) 
     134        { 
    131135                return uh_http_send(cl, req, message, -1); 
    132136        } 
     
    136140 
    137141 
    138 void uh_cgi_request( 
    139         struct client *cl, struct http_request *req, 
    140         struct path_info *pi, struct interpreter *ip 
    141 ) { 
     142void uh_cgi_request(struct client *cl, struct http_request *req, 
     143                                        struct path_info *pi, struct interpreter *ip) 
     144{ 
    142145        int i, hdroff, bufoff, rv; 
    143146        int hdrlen = 0; 
     
    166169 
    167170        /* spawn pipes for me->child, child->me */ 
    168         if( (pipe(rfd) < 0) || (pipe(wfd) < 0) ) 
     171        if ((pipe(rfd) < 0) || (pipe(wfd) < 0)) 
    169172        { 
    170173                uh_http_sendhf(cl, 500, "Internal Server Error", 
    171                         "Failed to create pipe: %s", strerror(errno)); 
    172  
    173                 if( rfd[0] > 0 ) close(rfd[0]); 
    174                 if( rfd[1] > 0 ) close(rfd[1]); 
    175                 if( wfd[0] > 0 ) close(wfd[0]); 
    176                 if( wfd[1] > 0 ) close(wfd[1]); 
     174                                           "Failed to create pipe: %s", strerror(errno)); 
     175 
     176                if (rfd[0] > 0) close(rfd[0]); 
     177                if (rfd[1] > 0) close(rfd[1]); 
     178                if (wfd[0] > 0) close(wfd[0]); 
     179                if (wfd[1] > 0) close(wfd[1]); 
    177180 
    178181                return; 
     
    180183 
    181184        /* fork off child process */ 
    182         switch( (child = fork()) ) 
     185        switch ((child = fork())) 
    183186        { 
    184187                /* oops */ 
    185188                case -1: 
    186189                        uh_http_sendhf(cl, 500, "Internal Server Error", 
    187                                 "Failed to fork child: %s", strerror(errno)); 
     190                                                   "Failed to fork child: %s", strerror(errno)); 
    188191                        return; 
    189192 
     
    213216 
    214217                        /* check for regular, world-executable file _or_ interpreter */ 
    215                         if( ((pi->stat.st_mode & S_IFREG) && 
    216                              (pi->stat.st_mode & S_IXOTH)) || (ip != NULL) 
    217                         ) { 
     218                        if (((pi->stat.st_mode & S_IFREG) && 
     219                             (pi->stat.st_mode & S_IXOTH)) || (ip != NULL)) 
     220                        { 
    218221                                /* build environment */ 
    219222                                clearenv(); 
     
    226229#ifdef HAVE_TLS 
    227230                                /* https? */ 
    228                                 if( cl->tls ) 
     231                                if (cl->tls) 
    229232                                        setenv("HTTPS", "on", 1); 
    230233#endif 
     
    244247                                setenv("QUERY_STRING", pi->query ? pi->query : "", 1); 
    245248 
    246                                 if( pi->info ) 
     249                                if (pi->info) 
    247250                                        setenv("PATH_INFO", pi->info, 1); 
    248251 
    249252                                /* REDIRECT_STATUS, php-cgi wants it */ 
    250                                 switch( req->redirect_status ) 
     253                                switch (req->redirect_status) 
    251254                                { 
    252255                                        case 404: 
     
    260263 
    261264                                /* http version */ 
    262                                 if( req->version > 1.0 ) 
     265                                if (req->version > 1.0) 
    263266                                        setenv("SERVER_PROTOCOL", "HTTP/1.1", 1); 
    264267                                else 
     
    266269 
    267270                                /* request method */ 
    268                                 switch( req->method ) 
     271                                switch (req->method) 
    269272                                { 
    270273                                        case UH_HTTP_MSG_GET: 
     
    285288 
    286289                                /* remote user */ 
    287                                 if( req->realm ) 
     290                                if (req->realm) 
    288291                                        setenv("REMOTE_USER", req->realm->user, 1); 
    289292 
     
    291294                                foreach_header(i, req->headers) 
    292295                                { 
    293                                         if( ! strcasecmp(req->headers[i], "Accept") ) 
     296                                        if (!strcasecmp(req->headers[i], "Accept")) 
    294297                                                setenv("HTTP_ACCEPT", req->headers[i+1], 1); 
    295298 
    296                                         else if( ! strcasecmp(req->headers[i], "Accept-Charset") ) 
     299                                        else if (!strcasecmp(req->headers[i], "Accept-Charset")) 
    297300                                                setenv("HTTP_ACCEPT_CHARSET", req->headers[i+1], 1); 
    298301 
    299                                         else if( ! strcasecmp(req->headers[i], "Accept-Encoding") ) 
     302                                        else if (!strcasecmp(req->headers[i], "Accept-Encoding")) 
    300303                                                setenv("HTTP_ACCEPT_ENCODING", req->headers[i+1], 1); 
    301304 
    302                                         else if( ! strcasecmp(req->headers[i], "Accept-Language") ) 
     305                                        else if (!strcasecmp(req->headers[i], "Accept-Language")) 
    303306                                                setenv("HTTP_ACCEPT_LANGUAGE", req->headers[i+1], 1); 
    304307 
    305                                         else if( ! strcasecmp(req->headers[i], "Authorization") ) 
     308                                        else if (!strcasecmp(req->headers[i], "Authorization")) 
    306309                                                setenv("HTTP_AUTHORIZATION", req->headers[i+1], 1); 
    307310 
    308                                         else if( ! strcasecmp(req->headers[i], "Connection") ) 
     311                                        else if (!strcasecmp(req->headers[i], "Connection")) 
    309312                                                setenv("HTTP_CONNECTION", req->headers[i+1], 1); 
    310313 
    311                                         else if( ! strcasecmp(req->headers[i], "Cookie") ) 
     314                                        else if (!strcasecmp(req->headers[i], "Cookie")) 
    312315                                                setenv("HTTP_COOKIE", req->headers[i+1], 1); 
    313316 
    314                                         else if( ! strcasecmp(req->headers[i], "Host") ) 
     317                                        else if (!strcasecmp(req->headers[i], "Host")) 
    315318                                                setenv("HTTP_HOST", req->headers[i+1], 1); 
    316319 
    317                                         else if( ! strcasecmp(req->headers[i], "Referer") ) 
     320                                        else if (!strcasecmp(req->headers[i], "Referer")) 
    318321                                                setenv("HTTP_REFERER", req->headers[i+1], 1); 
    319322 
    320                                         else if( ! strcasecmp(req->headers[i], "User-Agent") ) 
     323                                        else if (!strcasecmp(req->headers[i], "User-Agent")) 
    321324                                                setenv("HTTP_USER_AGENT", req->headers[i+1], 1); 
    322325 
    323                                         else if( ! strcasecmp(req->headers[i], "Content-Type") ) 
     326                                        else if (!strcasecmp(req->headers[i], "Content-Type")) 
    324327                                                setenv("CONTENT_TYPE", req->headers[i+1], 1); 
    325328 
    326                                         else if( ! strcasecmp(req->headers[i], "Content-Length") ) 
     329                                        else if (!strcasecmp(req->headers[i], "Content-Length")) 
    327330                                                setenv("CONTENT_LENGTH", req->headers[i+1], 1); 
    328331                                } 
     
    330333 
    331334                                /* execute child code ... */ 
    332                                 if( chdir(pi->root) ) 
     335                                if (chdir(pi->root)) 
    333336                                        perror("chdir()"); 
    334337 
    335                                 if( ip != NULL ) 
     338                                if (ip != NULL) 
    336339                                        execl(ip->path, ip->path, pi->phys, NULL); 
    337340                                else 
     
    339342 
    340343                                /* in case it fails ... */ 
    341                                 printf( 
    342                                         "Status: 500 Internal Server Error\r\n\r\n" 
    343                                         "Unable to launch the requested CGI program:\n" 
    344                                         "  %s: %s\n", 
    345                                                 ip ? ip->path : pi->phys, strerror(errno) 
    346                                 ); 
     344                                printf("Status: 500 Internal Server Error\r\n\r\n" 
     345                                           "Unable to launch the requested CGI program:\n" 
     346                                           "  %s: %s\n", 
     347                                           ip ? ip->path : pi->phys, strerror(errno)); 
    347348                        } 
    348349 
     
    350351                        else 
    351352                        { 
    352                                 printf( 
    353                                         "Status: 403 Forbidden\r\n\r\n" 
    354                                         "Access to this resource is forbidden\n" 
    355                                 ); 
     353                                printf("Status: 403 Forbidden\r\n\r\n" 
     354                                           "Access to this resource is forbidden\n"); 
    356355                        } 
    357356 
     
    372371 
    373372                        /* find content length */ 
    374                         if( req->method == UH_HTTP_MSG_POST ) 
     373                        if (req->method == UH_HTTP_MSG_POST) 
    375374                        { 
    376375                                foreach_header(i, req->headers) 
    377376                                { 
    378                                         if( ! strcasecmp(req->headers[i], "Content-Length") ) 
     377                                        if (!strcasecmp(req->headers[i], "Content-Length")) 
    379378                                        { 
    380379                                                content_length = atoi(req->headers[i+1]); 
     
    388387 
    389388                        /* I/O loop, watch our pipe ends and dispatch child reads/writes from/to socket */ 
    390                         while( 1 ) 
     389                        while (1) 
    391390                        { 
    392391                                FD_ZERO(&reader); 
     
    400399 
    401400                                ensure_out(rv = select_intr(fd_max, &reader, 
    402                                         (content_length > -1) ? &writer : NULL, NULL, &timeout)); 
     401                                                                                        (content_length > -1) 
     402                                                                                                ? &writer : NULL, 
     403                                                                                        NULL, &timeout)); 
    403404 
    404405                                /* timeout */ 
    405                                 if( rv == 0 ) 
     406                                if (rv == 0) 
    406407                                { 
    407408                                        ensure_out(kill(child, 0)); 
     
    409410 
    410411                                /* wait until we can read or write or both */ 
    411                                 else if( rv > 0 ) 
     412                                else if (rv > 0) 
    412413                                { 
    413414                                        /* ready to write to cgi program */ 
    414                                         if( FD_ISSET(wfd[1], &writer) ) 
     415                                        if (FD_ISSET(wfd[1], &writer)) 
    415416                                        { 
    416417                                                /* there is unread post data waiting */ 
    417                                                 if( content_length > 0 ) 
     418                                                if (content_length > 0) 
    418419                                                { 
    419420                                                        /* read it from socket ... */ 
     
    421422                                                                min(content_length, sizeof(buf)))); 
    422423 
    423                                                         if( buflen > 0 ) 
     424                                                        if (buflen > 0) 
    424425                                                        { 
    425426                                                                /* ... and write it to child's stdin */ 
    426                                                                 if( write(wfd[1], buf, buflen) < 0 ) 
     427                                                                if (write(wfd[1], buf, buflen) < 0) 
    427428                                                                        perror("write()"); 
    428429 
     
    433434                                                        else 
    434435                                                        { 
    435                                                                 if( write(wfd[1], "", 0) < 0 ) 
     436                                                                if (write(wfd[1], "", 0) < 0) 
    436437                                                                        perror("write()"); 
    437438 
     
    441442 
    442443                                                /* there is no more post data, close pipe to child's stdin */ 
    443                                                 else if( content_length > -1 ) 
     444                                                else if (content_length > -1) 
    444445                                                { 
    445446                                                        close(wfd[1]); 
     
    449450 
    450451                                        /* ready to read from cgi program */ 
    451                                         if( FD_ISSET(rfd[0], &reader) ) 
     452                                        if (FD_ISSET(rfd[0], &reader)) 
    452453                                        { 
    453454                                                /* read data from child ... */ 
    454                                                 if( (buflen = read(rfd[0], buf, sizeof(buf))) > 0 ) 
     455                                                if ((buflen = read(rfd[0], buf, sizeof(buf))) > 0) 
    455456                                                { 
    456457                                                        /* we have not pushed out headers yet, parse input */ 
    457                                                         if( ! header_sent ) 
     458                                                        if (!header_sent) 
    458459                                                        { 
    459460                                                                /* head buffer not full and no end yet */ 
    460                                                                 if( hdrlen < sizeof(hdr) ) 
     461                                                                if (hdrlen < sizeof(hdr)) 
    461462                                                                { 
    462463                                                                        bufoff = min(buflen, sizeof(hdr) - hdrlen); 
     
    471472 
    472473                                                                /* try to parse header ... */ 
    473                                                                 if( (res = uh_cgi_header_parse(hdr, hdrlen, &hdroff)) != NULL ) 
     474                                                                if ((res = uh_cgi_header_parse(hdr, hdrlen, &hdroff)) != NULL) 
    474475                                                                { 
    475476                                                                        /* write status */ 
     
    507508 
    508509                                                                        /* push out remaining head buffer */ 
    509                                                                         if( hdroff < hdrlen ) 
     510                                                                        if (hdroff < hdrlen) 
    510511                                                                                ensure_out(uh_http_send(cl, req, &hdr[hdroff], hdrlen - hdroff)); 
    511512                                                                } 
    512513 
    513514                                                                /* ... failed and head buffer exceeded */ 
    514                                                                 else if( hdrlen >= sizeof(hdr) ) 
     515                                                                else if (hdrlen >= sizeof(hdr)) 
    515516                                                                { 
    516517                                                                        ensure_out(uh_cgi_error_500(cl, req, 
     
    527528 
    528529                                                                /* push out remaining read buffer */ 
    529                                                                 if( bufoff < buflen ) 
     530                                                                if (bufoff < buflen) 
    530531                                                                        ensure_out(uh_http_send(cl, req, &buf[bufoff], buflen - bufoff)); 
    531532 
     
    543544                                                { 
    544545                                                        /* cgi script did not output useful stuff at all */ 
    545                                                         if( ! header_sent ) 
     546                                                        if (!header_sent) 
    546547                                                        { 
    547548                                                                /* I would do this ... 
     
    577578                                else 
    578579                                { 
    579                                         if( (errno != EINTR) && ! header_sent ) 
     580                                        if ((errno != EINTR) && ! header_sent) 
    580581                                        { 
    581582                                                ensure_out(uh_http_sendhf(cl, 504, "Gateway Timeout", 
     
    595596                        close(wfd[1]); 
    596597 
    597                         if( !kill(child, 0) ) 
     598                        if (!kill(child, 0)) 
    598599                        { 
    599600                                kill(child, SIGTERM); 
     
    604605        } 
    605606} 
    606  
  • trunk/package/uhttpd/src/uhttpd-file.c

    r28160 r31572  
    3232        const char *e; 
    3333 
    34         while( m->extn ) 
     34        while (m->extn) 
    3535        { 
    3636                e = &path[strlen(path)-1]; 
    3737 
    38                 while( e >= path ) 
    39                 { 
    40                         if( (*e == '.' || *e == '/') && !strcasecmp(&e[1], m->extn) ) 
     38                while (e >= path) 
     39                { 
     40                        if ((*e == '.' || *e == '/') && !strcasecmp(&e[1], m->extn)) 
    4141                                return m->mime; 
    4242 
     
    5555 
    5656        snprintf(tag, sizeof(tag), "\"%x-%x-%x\"", 
    57                 (unsigned int) s->st_ino, 
    58                 (unsigned int) s->st_size, 
    59                 (unsigned int) s->st_mtime 
    60         ); 
     57                         (unsigned int) s->st_ino, 
     58                         (unsigned int) s->st_size, 
     59                         (unsigned int) s->st_mtime); 
    6160 
    6261        return tag; 
     
    6968        memset(&t, 0, sizeof(t)); 
    7069 
    71         if( strptime(date, "%a, %d %b %Y %H:%M:%S %Z", &t) != NULL ) 
     70        if (strptime(date, "%a, %d %b %Y %H:%M:%S %Z", &t) != NULL) 
    7271                return timegm(&t); 
    7372 
     
    9190        foreach_header(i, req->headers) 
    9291        { 
    93                 if( ! strcasecmp(req->headers[i], name) ) 
     92                if (!strcasecmp(req->headers[i], name)) 
    9493                        return req->headers[i+1]; 
    9594        } 
     
    9998 
    10099 
    101 static int uh_file_response_ok_hdrs(struct client *cl, struct http_request *req, struct stat *s) 
     100static int uh_file_response_ok_hdrs(struct client *cl, struct http_request *req, 
     101                                                                        struct stat *s) 
    102102{ 
    103103        ensure_ret(uh_http_sendf(cl, NULL, "Connection: close\r\n")); 
    104104 
    105         if( s ) 
     105        if (s) 
    106106        { 
    107107                ensure_ret(uh_http_sendf(cl, NULL, "ETag: %s\r\n", uh_file_mktag(s))); 
    108                 ensure_ret(uh_http_sendf(cl, NULL, "Last-Modified: %s\r\n", uh_file_unix2date(s->st_mtime))); 
     108                ensure_ret(uh_http_sendf(cl, NULL, "Last-Modified: %s\r\n", 
     109                                                                 uh_file_unix2date(s->st_mtime))); 
    109110        } 
    110111 
     
    112113} 
    113114 
    114 static int uh_file_response_200(struct client *cl, struct http_request *req, struct stat *s) 
     115static int uh_file_response_200(struct client *cl, struct http_request *req, 
     116                                                                struct stat *s) 
    115117{ 
    116118        ensure_ret(uh_http_sendf(cl, NULL, "HTTP/%.1f 200 OK\r\n", req->version)); 
     
    118120} 
    119121 
    120 static int uh_file_response_304(struct client *cl, struct http_request *req, struct stat *s) 
     122static int uh_file_response_304(struct client *cl, struct http_request *req, 
     123                                                                struct stat *s) 
    121124{ 
    122125        ensure_ret(uh_http_sendf(cl, NULL, "HTTP/%.1f 304 Not Modified\r\n", req->version)); 
     
    131134} 
    132135 
    133 static int uh_file_if_match(struct client *cl, struct http_request *req, struct stat *s, int *ok) 
     136static int uh_file_if_match(struct client *cl, struct http_request *req, 
     137                                                        struct stat *s, int *ok) 
    134138{ 
    135139        const char *tag = uh_file_mktag(s); 
     
    138142        int i; 
    139143 
    140         if( hdr ) 
     144        if (hdr) 
    141145        { 
    142146                p = &hdr[0]; 
    143147 
    144                 for( i = 0; i < strlen(hdr); i++ ) 
    145                 { 
    146                         if( (hdr[i] == ' ') || (hdr[i] == ',') ) 
     148                for (i = 0; i < strlen(hdr); i++) 
     149                { 
     150                        if ((hdr[i] == ' ') || (hdr[i] == ',')) 
    147151                        { 
    148152                                hdr[i++] = 0; 
    149153                                p = &hdr[i]; 
    150154                        } 
    151                         else if( !strcmp(p, "*") || !strcmp(p, tag) ) 
     155                        else if (!strcmp(p, "*") || !strcmp(p, tag)) 
    152156                        { 
    153157                                *ok = 1; 
     
    165169} 
    166170 
    167 static int uh_file_if_modified_since(struct client *cl, struct http_request *req, struct stat *s, int *ok) 
     171static int uh_file_if_modified_since(struct client *cl, 
     172                                                                         struct http_request *req, struct stat *s, 
     173                                                                         int *ok) 
    168174{ 
    169175        char *hdr = uh_file_header_lookup(req, "If-Modified-Since"); 
    170176        *ok = 1; 
    171177 
    172         if( hdr ) 
    173         { 
    174                 if( uh_file_date2unix(hdr) >= s->st_mtime ) 
     178        if (hdr) 
     179        { 
     180                if (uh_file_date2unix(hdr) >= s->st_mtime) 
    175181                { 
    176182                        *ok = 0; 
     
    182188} 
    183189 
    184 static int uh_file_if_none_match(struct client *cl, struct http_request *req, struct stat *s, int *ok) 
     190static int uh_file_if_none_match(struct client *cl, struct http_request *req, 
     191                                                                 struct stat *s, int *ok) 
    185192{ 
    186193        const char *tag = uh_file_mktag(s); 
     
    190197        *ok = 1; 
    191198 
    192         if( hdr ) 
     199        if (hdr) 
    193200        { 
    194201                p = &hdr[0]; 
    195202 
    196                 for( i = 0; i < strlen(hdr); i++ ) 
    197                 { 
    198                         if( (hdr[i] == ' ') || (hdr[i] == ',') ) 
     203                for (i = 0; i < strlen(hdr); i++) 
     204                { 
     205                        if ((hdr[i] == ' ') || (hdr[i] == ',')) 
    199206                        { 
    200207                                hdr[i++] = 0; 
    201208                                p = &hdr[i]; 
    202209                        } 
    203                         else if( !strcmp(p, "*") || !strcmp(p, tag) ) 
     210                        else if (!strcmp(p, "*") || !strcmp(p, tag)) 
    204211                        { 
    205212                                *ok = 0; 
    206213 
    207                                 if( (req->method == UH_HTTP_MSG_GET) || 
    208                                     (req->method == UH_HTTP_MSG_HEAD) ) 
     214                                if ((req->method == UH_HTTP_MSG_GET) || 
     215                                    (req->method == UH_HTTP_MSG_HEAD)) 
     216                                { 
    209217                                        ensure_ret(uh_file_response_304(cl, req, s)); 
     218                                } 
    210219                                else 
     220                                { 
    211221                                        ensure_ret(uh_file_response_412(cl, req)); 
     222                                } 
    212223 
    213224                                break; 
     
    219230} 
    220231 
    221 static int uh_file_if_range(struct client *cl, struct http_request *req, struct stat *s, int *ok) 
     232static int uh_file_if_range(struct client *cl, struct http_request *req, 
     233                                                        struct stat *s, int *ok) 
    222234{ 
    223235        char *hdr = uh_file_header_lookup(req, "If-Range"); 
    224236        *ok = 1; 
    225237 
    226         if( hdr ) 
     238        if (hdr) 
    227239        { 
    228240                *ok = 0; 
     
    233245} 
    234246 
    235 static int uh_file_if_unmodified_since(struct client *cl, struct http_request *req, struct stat *s, int *ok) 
     247static int uh_file_if_unmodified_since(struct client *cl, 
     248                                                                           struct http_request *req, struct stat *s, 
     249                                                                           int *ok) 
    236250{ 
    237251        char *hdr = uh_file_header_lookup(req, "If-Unmodified-Since"); 
    238252        *ok = 1; 
    239253 
    240         if( hdr ) 
    241         { 
    242                 if( uh_file_date2unix(hdr) <= s->st_mtime ) 
     254        if (hdr) 
     255        { 
     256                if (uh_file_date2unix(hdr) <= s->st_mtime) 
    243257                { 
    244258                        *ok = 0; 
     
    256270} 
    257271 
    258 static void uh_file_dirlist(struct client *cl, struct http_request *req, struct path_info *pi) 
     272static void uh_file_dirlist(struct client *cl, struct http_request *req, 
     273                                                        struct path_info *pi) 
    259274{ 
    260275        int i; 
     
    266281 
    267282        ensure_out(uh_http_sendf(cl, req, 
    268                 "<html><head><title>Index of %s</title></head>" 
    269                 "<body><h1>Index of %s</h1><hr /><ol>", 
    270                         pi->name, pi->name 
    271         )); 
    272  
    273         if( (count = scandir(pi->phys, &files, uh_file_scandir_filter_dir, alphasort)) > 0 ) 
     283                                                         "<html><head><title>Index of %s</title></head>" 
     284                                                         "<body><h1>Index of %s</h1><hr /><ol>", 
     285                                                         pi->name, pi->name)); 
     286 
     287        if ((count = scandir(pi->phys, &files, uh_file_scandir_filter_dir, 
     288                                                 alphasort)) > 0) 
    274289        { 
    275290                memset(filename, 0, sizeof(filename)); 
     
    278293 
    279294                /* list subdirs */ 
    280                 for( i = 0; i < count; i++ ) 
     295                for (i = 0; i < count; i++) 
    281296                { 
    282297                        strncat(filename, files[i]->d_name, 
    283                                 sizeof(filename) - strlen(files[i]->d_name)); 
    284  
    285                         if( !stat(filename, &s) && 
    286                             (s.st_mode & S_IFDIR) && (s.st_mode & S_IXOTH) 
    287                         ) 
     298                                        sizeof(filename) - strlen(files[i]->d_name)); 
     299 
     300                        if (!stat(filename, &s) && 
     301                                (s.st_mode & S_IFDIR) && (s.st_mode & S_IXOTH)) 
     302                        { 
    288303                                ensure_out(uh_http_sendf(cl, req, 
    289                                         "<li><strong><a href='%s%s'>%s</a>/</strong><br />" 
    290                                         "<small>modified: %s<br />directory - %.02f kbyte" 
    291                                         "<br /><br /></small></li>", 
    292                                                 pi->name, files[i]->d_name, files[i]->d_name, 
    293                                                 uh_file_unix2date(s.st_mtime), s.st_size / 1024.0 
    294                                 )); 
     304                                                                                 "<li><strong><a href='%s%s'>%s</a>/" 
     305                                                                                 "</strong><br /><small>modified: %s" 
     306                                                                                 "<br />directory - %.02f kbyte<br />" 
     307                                                                                 "<br /></small></li>", 
     308                                                                                 pi->name, files[i]->d_name, 
     309                                                                                 files[i]->d_name, 
     310                                                                                 uh_file_unix2date(s.st_mtime), 
     311                                                                                 s.st_size / 1024.0)); 
     312                        } 
    295313 
    296314                        *pathptr = 0; 
     
    298316 
    299317                /* list files */ 
    300                 for( i = 0; i < count; i++ ) 
     318                for (i = 0; i < count; i++) 
    301319                { 
    302320                        strncat(filename, files[i]->d_name, 
    303                                 sizeof(filename) - strlen(files[i]->d_name)); 
    304  
    305                         if( !stat(filename, &s) && 
    306                             !(s.st_mode & S_IFDIR) && (s.st_mode & S_IROTH) 
    307                         ) 
     321                                        sizeof(filename) - strlen(files[i]->d_name)); 
     322 
     323                        if (!stat(filename, &s) && 
     324                                !(s.st_mode & S_IFDIR) && (s.st_mode & S_IROTH)) 
     325                        { 
    308326                                ensure_out(uh_http_sendf(cl, req, 
    309                                         "<li><strong><a href='%s%s'>%s</a></strong><br />" 
    310                                         "<small>modified: %s<br />%s - %.02f kbyte<br />" 
    311                                         "<br /></small></li>", 
    312                                                 pi->name, files[i]->d_name, files[i]->d_name, 
    313                                                 uh_file_unix2date(s.st_mtime), 
    314                                                 uh_file_mime_lookup(filename), s.st_size / 1024.0 
    315                                 )); 
     327                                                                                 "<li><strong><a href='%s%s'>%s</a>" 
     328                                                                                 "</strong><br /><small>modified: %s" 
     329                                                                                 "<br />%s - %.02f kbyte<br />" 
     330                                                                                 "<br /></small></li>", 
     331                                                                                 pi->name, files[i]->d_name, 
     332                                                                                 files[i]->d_name, 
     333                                                                                 uh_file_unix2date(s.st_mtime), 
     334                                                                                 uh_file_mime_lookup(filename), 
     335                                                                                 s.st_size / 1024.0)); 
     336                        } 
    316337 
    317338                        *pathptr = 0; 
     
    323344 
    324345out: 
    325         if( files ) 
    326         { 
    327                 for( i = 0; i < count; i++ ) 
     346        if (files) 
     347        { 
     348                for (i = 0; i < count; i++) 
    328349                        free(files[i]); 
    329350 
     
    341362 
    342363        /* we have a file */ 
    343         if( (pi->stat.st_mode & S_IFREG) && ((fd = open(pi->phys, O_RDONLY)) > 0) ) 
     364        if ((pi->stat.st_mode & S_IFREG) && ((fd = open(pi->phys, O_RDONLY)) > 0)) 
    344365        { 
    345366                /* test preconditions */ 
    346                 if(ok) ensure_out(uh_file_if_modified_since(cl, req, &pi->stat, &ok)); 
    347                 if(ok) ensure_out(uh_file_if_match(cl, req, &pi->stat, &ok)); 
    348                 if(ok) ensure_out(uh_file_if_range(cl, req, &pi->stat, &ok)); 
    349                 if(ok) ensure_out(uh_file_if_unmodified_since(cl, req, &pi->stat, &ok)); 
    350                 if(ok) ensure_out(uh_file_if_none_match(cl, req, &pi->stat, &ok)); 
    351  
    352                 if( ok > 0 ) 
     367                if (ok) ensure_out(uh_file_if_modified_since(cl, req, &pi->stat, &ok)); 
     368                if (ok) ensure_out(uh_file_if_match(cl, req, &pi->stat, &ok)); 
     369                if (ok) ensure_out(uh_file_if_range(cl, req, &pi->stat, &ok)); 
     370                if (ok) ensure_out(uh_file_if_unmodified_since(cl, req, &pi->stat, &ok)); 
     371                if (ok) ensure_out(uh_file_if_none_match(cl, req, &pi->stat, &ok)); 
     372 
     373                if (ok > 0) 
    353374                { 
    354375                        /* write status */ 
     
    359380 
    360381                        /* if request was HTTP 1.1 we'll respond chunked */ 
    361                         if( (req->version > 1.0) && (req->method != UH_HTTP_MSG_HEAD) ) 
     382                        if ((req->version > 1.0) && (req->method != UH_HTTP_MSG_HEAD)) 
    362383                                ensure_out(uh_http_send(cl, NULL, "Transfer-Encoding: chunked\r\n", -1)); 
    363384 
     
    366387 
    367388                        /* send body */ 
    368                         if( req->method != UH_HTTP_MSG_HEAD ) 
     389                        if (req->method != UH_HTTP_MSG_HEAD) 
    369390                        { 
    370391                                /* pump file data */ 
    371                                 while( (rlen = read(fd, buf, sizeof(buf))) > 0 ) 
     392                                while ((rlen = read(fd, buf, sizeof(buf))) > 0) 
    372393                                        ensure_out(uh_http_send(cl, req, buf, rlen)); 
    373394 
     
    385406 
    386407        /* directory */ 
    387         else if( (pi->stat.st_mode & S_IFDIR) && !cl->server->conf->no_dirlists ) 
     408        else if ((pi->stat.st_mode & S_IFDIR) && !cl->server->conf->no_dirlists) 
    388409        { 
    389410                /* write status */ 
    390411                ensure_out(uh_file_response_200(cl, req, NULL)); 
    391412 
    392                 if( req->version > 1.0 ) 
     413                if (req->version > 1.0) 
    393414                        ensure_out(uh_http_send(cl, NULL, "Transfer-Encoding: chunked\r\n", -1)); 
    394415 
     
    407428 
    408429out: 
    409         if( fd > -1 ) 
     430        if (fd > -1) 
    410431                close(fd); 
    411432} 
    412  
  • trunk/package/uhttpd/src/uhttpd-lua.c

    r31571 r31572  
    3232        length = luaL_checknumber(L, 1); 
    3333 
    34         if( (length > 0) && (length <= sizeof(buffer)) ) 
     34        if ((length > 0) && (length <= sizeof(buffer))) 
    3535        { 
    3636                FD_ZERO(&reader); 
     
    4242 
    4343                /* check whether fd is readable */ 
    44                 if( select(fileno(stdin) + 1, &reader, NULL, NULL, &timeout) > 0 ) 
     44                if (select(fileno(stdin) + 1, &reader, NULL, NULL, &timeout) > 0) 
    4545                { 
    4646                        /* receive data */ 
     
    4848                        lua_pushnumber(L, rlen); 
    4949 
    50                         if( rlen > 0 ) 
     50                        if (rlen > 0) 
    5151                        { 
    5252                                lua_pushlstring(L, buffer, rlen); 
     
    7676        buffer = luaL_checklstring(L, 1, &length); 
    7777 
    78         if( chunked ) 
     78        if (chunked) 
    7979        { 
    80                 if( length > 0 ) 
     80                if (length > 0) 
    8181                { 
    8282                        snprintf(chunk, sizeof(chunk), "%X\r\n", length); 
     
    118118        inbuf = luaL_checklstring(L, 1, &inlen); 
    119119        outlen = (* xlate_func)(outbuf, sizeof(outbuf), inbuf, inlen); 
    120         if( outlen < 0 ) 
     120        if (outlen < 0) 
    121121                luaL_error( L, "%s on URL-encode codec", 
    122122                        (outlen==-1) ? "buffer overflow" : "malformed string" ); 
     
    178178 
    179179        /* load Lua handler */ 
    180         switch( luaL_loadfile(L, conf->lua_handler) ) 
     180        switch (luaL_loadfile(L, conf->lua_handler)) 
    181181        { 
    182182                case LUA_ERRSYNTAX: 
     
    197197                default: 
    198198                        /* compile Lua handler */ 
    199                         switch( lua_pcall(L, 0, 0, 0) ) 
     199                        switch (lua_pcall(L, 0, 0, 0)) 
    200200                        { 
    201201                                case LUA_ERRRUN: 
     
    219219                                        lua_getglobal(L, UH_LUA_CALLBACK); 
    220220 
    221                                         if( ! lua_isfunction(L, -1) ) 
     221                                        if (! lua_isfunction(L, -1)) 
    222222                                        { 
    223223                                                fprintf(stderr, 
     
    261261 
    262262        /* spawn pipes for me->child, child->me */ 
    263         if( (pipe(rfd) < 0) || (pipe(wfd) < 0) ) 
     263        if ((pipe(rfd) < 0) || (pipe(wfd) < 0)) 
    264264        { 
    265265                uh_http_sendhf(cl, 500, "Internal Server Error", 
    266266                        "Failed to create pipe: %s", strerror(errno)); 
    267267 
    268                 if( rfd[0] > 0 ) close(rfd[0]); 
    269                 if( rfd[1] > 0 ) close(rfd[1]); 
    270                 if( wfd[0] > 0 ) close(wfd[0]); 
    271                 if( wfd[1] > 0 ) close(wfd[1]); 
     268                if (rfd[0] > 0) close(rfd[0]); 
     269                if (rfd[1] > 0) close(rfd[1]); 
     270                if (wfd[0] > 0) close(wfd[0]); 
     271                if (wfd[1] > 0) close(wfd[1]); 
    272272 
    273273                return; 
     
    275275 
    276276 
    277         switch( (child = fork()) ) 
     277        switch ((child = fork())) 
    278278        { 
    279279                case -1: 
     
    330330 
    331331                        /* query string, path info */ 
    332                         if( (query_string = strchr(req->url, '?')) != NULL ) 
     332                        if ((query_string = strchr(req->url, '?')) != NULL) 
    333333                        { 
    334334                                lua_pushstring(L, query_string + 1); 
    335335                                lua_setfield(L, -2, "QUERY_STRING"); 
    336336 
    337                                 if( (int)(query_string - req->url) > strlen(prefix) ) 
     337                                if ((int)(query_string - req->url) > strlen(prefix)) 
    338338                                { 
    339339                                        lua_pushlstring(L, 
     
    345345                                } 
    346346                        } 
    347                         else if( strlen(req->url) > strlen(prefix) ) 
     347                        else if (strlen(req->url) > strlen(prefix)) 
    348348                        { 
    349349                                lua_pushstring(L, &req->url[strlen(prefix)]); 
     
    355355                        lua_setfield(L, -2, "HTTP_VERSION"); 
    356356 
    357                         if( req->version > 1.0 ) 
     357                        if (req->version > 1.0) 
    358358                                lua_pushstring(L, "HTTP/1.1"); 
    359359                        else 
     
    379379                        foreach_header(i, req->headers) 
    380380                        { 
    381                                 if( !strcasecmp(req->headers[i], "Content-Length") ) 
     381                                if (!strcasecmp(req->headers[i], "Content-Length")) 
    382382                                { 
    383383                                        lua_pushnumber(L, atoi(req->headers[i+1])); 
    384384                                        lua_setfield(L, -2, "CONTENT_LENGTH"); 
    385385                                } 
    386                                 else if( !strcasecmp(req->headers[i], "Content-Type") ) 
     386                                else if (!strcasecmp(req->headers[i], "Content-Type")) 
    387387                                { 
    388388                                        lua_pushstring(L, req->headers[i+1]); 
     
    408408 
    409409                        /* call */ 
    410                         switch( lua_pcall(L, 1, 0, 0) ) 
     410                        switch (lua_pcall(L, 1, 0, 0)) 
    411411                        { 
    412412                                case LUA_ERRMEM: 
     
    414414                                        err_str = luaL_checkstring(L, -1); 
    415415 
    416                                         if( ! err_str ) 
     416                                        if (! err_str) 
    417417                                                err_str = "Unknown error"; 
    418418 
     
    448448 
    449449                        /* find content length */ 
    450                         if( req->method == UH_HTTP_MSG_POST ) 
     450                        if (req->method == UH_HTTP_MSG_POST) 
    451451                        { 
    452452                                foreach_header(i, req->headers) 
    453453                                { 
    454                                         if( ! strcasecmp(req->headers[i], "Content-Length") ) 
     454                                        if (! strcasecmp(req->headers[i], "Content-Length")) 
    455455                                        { 
    456456                                                content_length = atoi(req->headers[i+1]); 
     
    462462 
    463463#define ensure(x) \ 
    464         do { if( x < 0 ) goto out; } while(0) 
     464        do { if (x < 0) goto out; } while(0) 
    465465 
    466466                        data_sent = 0; 
     
    470470 
    471471                        /* I/O loop, watch our pipe ends and dispatch child reads/writes from/to socket */ 
    472                         while( 1 ) 
     472                        while (1) 
    473473                        { 
    474474                                FD_ZERO(&reader); 
     
    479479 
    480480                                /* wait until we can read or write or both */ 
    481                                 if( select_intr(fd_max, &reader, 
    482                                     (content_length > -1) ? &writer : NULL, NULL, 
    483                                         (data_sent < 1) ? &timeout : NULL) > 0 
    484                                 ) { 
     481                                if (select_intr(fd_max, &reader, 
     482                                                                (content_length > -1) ? &writer : NULL, 
     483                                                                NULL, 
     484                                                                (data_sent < 1) ? &timeout : NULL) > 0) 
     485                                { 
    485486                                        /* ready to write to Lua child */ 
    486                                         if( FD_ISSET(wfd[1], &writer) ) 
     487                                        if (FD_ISSET(wfd[1], &writer)) 
    487488                                        { 
    488489                                                /* there is unread post data waiting */ 
    489                                                 if( content_length > 0 ) 
     490                                                if (content_length > 0) 
    490491                                                { 
    491492                                                        /* read it from socket ... */ 
    492                                                         if( (buflen = uh_tcp_recv(cl, buf, min(content_length, sizeof(buf)))) > 0 ) 
     493                                                        if ((buflen = uh_tcp_recv(cl, buf, min(content_length, sizeof(buf)))) > 0) 
    493494                                                        { 
    494495                                                                /* ... and write it to child's stdin */ 
    495                                                                 if( write(wfd[1], buf, buflen) < 0 ) 
     496                                                                if (write(wfd[1], buf, buflen) < 0) 
    496497                                                                        perror("write()"); 
    497498 
     
    502503                                                        else 
    503504                                                        { 
    504                                                                 if( write(wfd[1], "", 0) < 0 ) 
     505                                                                if (write(wfd[1], "", 0) < 0) 
    505506                                                                        perror("write()"); 
    506507 
     
    510511 
    511512                                                /* there is no more post data, close pipe to child's stdin */ 
    512                                                 else if( content_length > -1 ) 
     513                                                else if (content_length > -1) 
    513514                                                { 
    514515                                                        close(wfd[1]); 
     
    518519 
    519520                                        /* ready to read from Lua child */ 
    520                                         if( FD_ISSET(rfd[0], &reader) ) 
     521                                        if (FD_ISSET(rfd[0], &reader)) 
    521522                                        { 
    522523                                                /* read data from child ... */ 
    523                                                 if( (buflen = read(rfd[0], buf, sizeof(buf))) > 0 ) 
     524                                                if ((buflen = read(rfd[0], buf, sizeof(buf))) > 0) 
    524525                                                { 
    525526                                                        /* pass through buffer to socket */ 
     
    532533                                                { 
    533534                                                        /* error? */ 
    534                                                         if( ! data_sent ) 
     535                                                        if (!data_sent) 
    535536                                                                uh_http_sendhf(cl, 500, "Internal Server Error", 
    536537                                                                        "The Lua child did not produce any response"); 
     
    544545                                else 
    545546                                { 
    546                                         if( (errno != EINTR) && ! data_sent ) 
     547                                        if ((errno != EINTR) && ! data_sent) 
    547548                                        { 
    548549                                                ensure(uh_http_sendhf(cl, 504, "Gateway Timeout", 
     
    559560                        close(wfd[1]); 
    560561 
    561                         if( !kill(child, 0) ) 
     562                        if (!kill(child, 0)) 
    562563                        { 
    563564                                kill(child, SIGTERM); 
  • trunk/package/uhttpd/src/uhttpd-utils.c

    r31570 r31572  
    4242        struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)sa; 
    4343 
    44         if( v4->sin_family == AF_INET ) 
     44        if (v4->sin_family == AF_INET) 
    4545                return inet_ntop(AF_INET, &(v4->sin_addr), str, sizeof(str)); 
    4646        else 
     
    6565        unsigned long a = htonl(v4->sin_addr.s_addr); 
    6666 
    67         if( v4->sin_family == AF_INET ) 
     67        if (v4->sin_family == AF_INET) 
    6868        { 
    6969                return ((a >= 0x0A000000) && (a <= 0x0AFFFFFF)) || 
     
    8181        int i, j; 
    8282 
    83         for( i = 0; i < hslen; i++ ) 
    84         { 
    85                 if( haystack[i] == needle[0] ) 
     83        for (i = 0; i < hslen; i++) 
     84        { 
     85                if (haystack[i] == needle[0]) 
    8686                { 
    8787                        match = ((ndlen == 1) || ((i + ndlen) <= hslen)); 
    8888 
    89                         for( j = 1; (j < ndlen) && ((i + j) < hslen); j++ ) 
    90                         { 
    91                                 if( haystack[i+j] != needle[j] ) 
     89                        for (j = 1; (j < ndlen) && ((i + j) < hslen); j++) 
     90                        { 
     91                                if (haystack[i+j] != needle[j]) 
    9292                                { 
    9393                                        match = 0; 
     
    9696                        } 
    9797 
    98                         if( match ) 
     98                        if (match) 
    9999                                return &haystack[i]; 
    100100                } 
     
    161161 
    162162        /* store received data in peek buffer */ 
    163         if( sz > 0 ) 
     163        if (sz > 0) 
    164164        { 
    165165                cl->peeklen = sz; 
     
    221221 
    222222 
    223 int uh_http_sendhf(struct client *cl, int code, const char *summary, const char *fmt, ...) 
     223int uh_http_sendhf(struct client *cl, int code, const char *summary, 
     224                                   const char *fmt, ...) 
    224225{ 
    225226        va_list ap; 
     
    254255        int clen; 
    255256 
    256         if( len == -1 ) 
     257        if (len == -1) 
    257258                len = strlen(data); 
    258259 
    259         if( len > 0 ) 
     260        if (len > 0) 
    260261        { 
    261262                clen = snprintf(chunk, sizeof(chunk), "%X\r\n", len); 
     
    272273} 
    273274 
    274 int uh_http_sendf( 
    275         struct client *cl, struct http_request *req, const char *fmt, ... 
    276 ) { 
     275int uh_http_sendf(struct client *cl, struct http_request *req, 
     276                                  const char *fmt, ...) 
     277{ 
    277278        va_list ap; 
    278279        char buffer[UH_LIMIT_MSGHEAD]; 
     
    283284        va_end(ap); 
    284285 
    285         if( (req != NULL) && (req->version > 1.0) ) 
     286        if ((req != NULL) && (req->version > 1.0)) 
    286287                ensure_ret(uh_http_sendc(cl, buffer, len)); 
    287         else if( len > 0 ) 
     288        else if (len > 0) 
    288289                ensure_ret(uh_tcp_send(cl, buffer, len)); 
    289290 
     
    291292} 
    292293 
    293 int uh_http_send( 
    294         struct client *cl, struct http_request *req, const char *buf, int len 
    295 ) { 
    296         if( len < 0 ) 
     294int uh_http_send(struct client *cl, struct http_request *req, 
     295                                 const char *buf, int len) 
     296{ 
     297        if (len < 0) 
    297298                len = strlen(buf); 
    298299 
    299         if( (req != NULL) && (req->version > 1.0) ) 
     300        if ((req != NULL) && (req->version > 1.0)) 
    300301                ensure_ret(uh_http_sendc(cl, buf, len)); 
    301         else if( len > 0 ) 
     302        else if (len > 0) 
    302303                ensure_ret(uh_tcp_send(cl, buf, len)); 
    303304 
     
    319320                        ((x) - 'a' + 10))) 
    320321 
    321         for( i = 0; (i < slen) && (len < blen); i++ ) 
    322         { 
    323                 if( src[i] == '%' ) 
    324                 { 
    325                         if( ((i+2) < slen) && isxdigit(src[i+1]) && isxdigit(src[i+2]) ) 
     322        for (i = 0; (i < slen) && (len < blen); i++) 
     323        { 
     324                if (src[i] == '%') 
     325                { 
     326                        if (((i+2) < slen) && isxdigit(src[i+1]) && isxdigit(src[i+2])) 
    326327                        { 
    327328                                buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2])); 
     
    359360        const char hex[] = "0123456789abcdef"; 
    360361 
    361         for( i = 0; (i < slen) && (len < blen); i++ ) 
     362        for (i = 0; (i < slen) && (len < blen); i++) 
    362363        { 
    363364                if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') || 
     
    366367                        buf[len++] = src[i]; 
    367368                } 
    368                 else if( (len+3) <= blen ) 
     369                else if ((len+3) <= blen) 
    369370                { 
    370371                        buf[len++] = '%'; 
     
    391392 
    392393 
    393         for( i = 0; (i <= slen) && (src[i] != 0); i++ ) 
     394        for (i = 0; (i <= slen) && (src[i] != 0); i++) 
    394395        { 
    395396                cin = src[i]; 
    396397 
    397                 if( (cin >= '0') && (cin <= '9') ) 
     398                if ((cin >= '0') && (cin <= '9')) 
    398399                        cin = cin - '0' + 52; 
    399                 else if( (cin >= 'A') && (cin <= 'Z') ) 
     400                else if ((cin >= 'A') && (cin <= 'Z')) 
    400401                        cin = cin - 'A'; 
    401                 else if( (cin >= 'a') && (cin <= 'z') ) 
     402                else if ((cin >= 'a') && (cin <= 'z')) 
    402403                        cin = cin - 'a' + 26; 
    403                 else if( cin == '+' ) 
     404                else if (cin == '+') 
    404405                        cin = 62; 
    405                 else if( cin == '/' ) 
     406                else if (cin == '/') 
    406407                        cin = 63; 
    407                 else if( cin == '=' ) 
     408                else if (cin == '=') 
    408409                        cin = 0; 
    409410                else 
     
    412413                cout = (cout << 6) | cin; 
    413414 
    414                 if( (i % 4) == 3 ) 
    415                 { 
    416                         if( (len + 3) < blen ) 
     415                if ((i % 4) == 3) 
     416                { 
     417                        if ((len + 3) < blen) 
    417418                        { 
    418419                                buf[len++] = (char)(cout >> 16); 
     
    441442 
    442443        /* relative -> absolute */ 
    443         if( *path != '/' ) 
     444        if (*path != '/') 
    444445        { 
    445446                getcwd(path_copy, PATH_MAX); 
     
    453454 
    454455        /* normalize */ 
    455         while( (*path_cpy != '\0') && (path_cpy < (path_copy + PATH_MAX - 2)) ) 
    456         { 
    457                 if( *path_cpy == '/' ) 
     456        while ((*path_cpy != '\0') && (path_cpy < (path_copy + PATH_MAX - 2))) 
     457        { 
     458                if (*path_cpy == '/') 
    458459                { 
    459460                        /* skip repeating / */ 
    460                         if( path_cpy[1] == '/' ) 
     461                        if (path_cpy[1] == '/') 
    461462                        { 
    462463                                path_cpy++; 
     
    465466 
    466467                        /* /./ or /../ */ 
    467                         else if( path_cpy[1] == '.' ) 
     468                        else if (path_cpy[1] == '.') 
    468469                        { 
    469470                                /* skip /./ */ 
    470                                 if( (path_cpy[2] == '/') || (path_cpy[2] == '\0') ) 
     471                                if ((path_cpy[2] == '/') || (path_cpy[2] == '\0')) 
    471472                                { 
    472473                                        path_cpy += 2; 
     
    475476 
    476477                                /* collapse /x/../ */ 
    477                                 else if( (path_cpy[2] == '.') && 
    478                                          ((path_cpy[3] == '/') || (path_cpy[3] == '\0')) 
    479                                 ) { 
    480                                         while( (path_res > path_resolved) && (*--path_res != '/') ) 
     478                                else if ((path_cpy[2] == '.') && 
     479                                                 ((path_cpy[3] == '/') || (path_cpy[3] == '\0'))) 
     480                                { 
     481                                        while ((path_res > path_resolved) && (*--path_res != '/')) 
    481482                                                ; 
    482483 
     
    491492 
    492493        /* remove trailing slash if not root / */ 
    493         if( (path_res > (path_resolved+1)) && (path_res[-1] == '/') ) 
     494        if ((path_res > (path_resolved+1)) && (path_res[-1] == '/')) 
    494495                path_res--; 
    495         else if( path_res == path_resolved ) 
     496        else if (path_res == path_resolved) 
    496497                *path_res++ = '/'; 
    497498 
     
    499500 
    500501        /* test access */ 
    501         if( !stat(path_resolved, &s) && (s.st_mode & S_IROTH) ) 
     502        if (!stat(path_resolved, &s) && (s.st_mode & S_IROTH)) 
    502503                return path_resolved; 
    503504 
     
    524525 
    525526        /* back out early if url is undefined */ 
    526         if ( url == NULL ) 
     527        if (url == NULL) 
    527528                return NULL; 
    528529 
     
    534535        /* copy docroot */ 
    535536        memcpy(buffer, docroot, 
    536                 min(strlen(docroot), sizeof(buffer) - 1)); 
     537                   min(strlen(docroot), sizeof(buffer) - 1)); 
    537538 
    538539        /* separate query string from url */ 
    539         if( (pathptr = strchr(url, '?')) != NULL ) 
     540        if ((pathptr = strchr(url, '?')) != NULL) 
    540541        { 
    541542                p.query = pathptr[1] ? pathptr + 1 : NULL; 
    542543 
    543544                /* urldecode component w/o query */ 
    544                 if( pathptr > url ) 
    545                         if ( uh_urldecode( 
    546                                         &buffer[strlen(docroot)], 
    547                                         sizeof(buffer) - strlen(docroot) - 1, 
    548                                         url, pathptr - url ) < 0 ) 
     545                if (pathptr > url) 
     546                { 
     547                        if (uh_urldecode(&buffer[strlen(docroot)], 
     548                                                         sizeof(buffer) - strlen(docroot) - 1, 
     549                                                         url, pathptr - url ) < 0) 
     550                        { 
    549551                                return NULL; /* bad URL */ 
     552                        } 
     553                } 
    550554        } 
    551555 
     
    553557        else 
    554558        { 
    555                 if ( uh_urldecode( 
    556                                 &buffer[strlen(docroot)], 
    557                                 sizeof(buffer) - strlen(docroot) - 1, 
    558                                 url, strlen(url) ) < 0 ) 
     559                if (uh_urldecode(&buffer[strlen(docroot)], 
     560                                                 sizeof(buffer) - strlen(docroot) - 1, 
     561                                                 url, strlen(url) ) < 0) 
     562                { 
    559563                        return NULL; /* bad URL */ 
     564                } 
    560565        } 
    561566 
    562567        /* create canon path */ 
    563         for( i = strlen(buffer), slash = (buffer[max(0, i-1)] == '/'); i >= 0; i-- ) 
    564         { 
    565                 if( (buffer[i] == 0) || (buffer[i] == '/') ) 
     568        for (i = strlen(buffer), slash = (buffer[max(0, i-1)] == '/'); i >= 0; i--) 
     569        { 
     570                if ((buffer[i] == 0) || (buffer[i] == '/')) 
    566571                { 
    567572                        memset(path_info, 0, sizeof(path_info)); 
    568573                        memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1)); 
    569574 
    570                         if( no_sym ? realpath(path_info, path_phys) 
    571                                    : canonpath(path_info, path_phys) 
    572                         ) { 
     575                        if (no_sym ? realpath(path_info, path_phys) 
     576                                   : canonpath(path_info, path_phys)) 
     577                        { 
    573578                                memset(path_info, 0, sizeof(path_info)); 
    574579                                memcpy(path_info, &buffer[i], 
    575                                         min(strlen(buffer) - i, sizeof(path_info) - 1)); 
     580                                           min(strlen(buffer) - i, sizeof(path_info) - 1)); 
    576581 
    577582                                break; 
     
    581586 
    582587        /* check whether found path is within docroot */ 
    583         if( strncmp(path_phys, docroot, strlen(docroot)) || 
    584             ((path_phys[strlen(docroot)] != 0) && 
    585                  (path_phys[strlen(docroot)] != '/')) 
    586         ) { 
     588        if (strncmp(path_phys, docroot, strlen(docroot)) || 
     589                ((path_phys[strlen(docroot)] != 0) && 
     590                 (path_phys[strlen(docroot)] != '/'))) 
     591        { 
    587592                return NULL; 
    588593        } 
    589594 
    590595        /* test current path */ 
    591         if( ! stat(path_phys, &p.stat) ) 
     596        if (!stat(path_phys, &p.stat)) 
    592597        { 
    593598                /* is a regular file */ 
    594                 if( p.stat.st_mode & S_IFREG ) 
     599                if (p.stat.st_mode & S_IFREG) 
    595600                { 
    596601                        p.root = docroot; 
     
    601606 
    602607                /* is a directory */ 
    603                 else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) ) 
     608                else if ((p.stat.st_mode & S_IFDIR) && !strlen(path_info)) 
    604609                { 
    605610                        /* ensure trailing slash */ 
    606                         if( path_phys[strlen(path_phys)-1] != '/' ) 
     611                        if (path_phys[strlen(path_phys)-1] != '/') 
    607612                                path_phys[strlen(path_phys)] = '/'; 
    608613 
     
    615620                           is missing in the request url, redirect the client to the same 
    616621                           url with trailing slash appended */ 
    617                         if( !slash ) 
     622                        if (!slash) 
    618623                        { 
    619624                                uh_http_sendf(cl, NULL, 
     
    628633                                p.redirected = 1; 
    629634                        } 
    630                         else if( cl->server->conf->index_file ) 
     635                        else if (cl->server->conf->index_file) 
    631636                        { 
    632637                                strncat(buffer, cl->server->conf->index_file, sizeof(buffer)); 
    633638 
    634                                 if( !stat(buffer, &s) && (s.st_mode & S_IFREG) ) 
     639                                if (!stat(buffer, &s) && (s.st_mode & S_IFREG)) 
    635640                                { 
    636641                                        memcpy(path_phys, buffer, sizeof(path_phys)); 
     
    640645                        else 
    641646                        { 
    642                                 for( i = 0; i < array_size(uh_index_files); i++ ) 
     647                                for (i = 0; i < array_size(uh_index_files); i++) 
    643648                                { 
    644649                                        strncat(buffer, uh_index_files[i], sizeof(buffer)); 
    645650 
    646                                         if( !stat(buffer, &s) && (s.st_mode & S_IFREG) ) 
     651                                        if (!stat(buffer, &s) && (s.st_mode & S_IFREG)) 
    647652                                        { 
    648653                                                memcpy(path_phys, buffer, sizeof(path_phys)); 
     
    681686 
    682687                memcpy(new->path, path, 
    683                         min(strlen(path), sizeof(new->path) - 1)); 
     688                           min(strlen(path), sizeof(new->path) - 1)); 
    684689 
    685690                memcpy(new->user, user, 
    686                         min(strlen(user), sizeof(new->user) - 1)); 
     691                           min(strlen(user), sizeof(new->user) - 1)); 
    687692 
    688693                /* given password refers to a passwd entry */ 
    689                 if( (strlen(pass) > 3) && !strncmp(pass, "$p$", 3) ) 
     694                if ((strlen(pass) > 3) && !strncmp(pass, "$p$", 3)) 
    690695                { 
    691696#ifdef HAVE_SHADOW 
    692697                        /* try to resolve shadow entry */ 
    693                         if( ((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp ) 
     698                        if (((spwd = getspnam(&pass[3])) != NULL) && spwd->sp_pwdp) 
    694699                        { 
    695700                                memcpy(new->pass, spwd->sp_pwdp, 
    696                                         min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1)); 
     701                                           min(strlen(spwd->sp_pwdp), sizeof(new->pass) - 1)); 
    697702                        } 
    698703 
     
    701706 
    702707                        /* try to resolve passwd entry */ 
    703                         if( ((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd && 
    704                                 (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0) 
    705                         ) { 
     708                        if (((pwd = getpwnam(&pass[3])) != NULL) && pwd->pw_passwd && 
     709                                (pwd->pw_passwd[0] != '!') && (pwd->pw_passwd[0] != 0)) 
     710                        { 
    706711                                memcpy(new->pass, pwd->pw_passwd, 
    707                                         min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1)); 
     712                                           min(strlen(pwd->pw_passwd), sizeof(new->pass) - 1)); 
    708713                        } 
    709714                } 
     
    716721                } 
    717722 
    718                 if( new->pass[0] ) 
     723                if (new->pass[0]) 
    719724                { 
    720725                        new->next = uh_realms; 
     
    730735} 
    731736 
    732 int uh_auth_check( 
    733         struct client *cl, struct http_request *req, struct path_info *pi 
    734 ) { 
     737int uh_auth_check(struct client *cl, struct http_request *req, 
     738                                  struct path_info *pi) 
     739{ 
    735740        int i, plen, rlen, protected; 
    736741        char buffer[UH_LIMIT_MSGHEAD]; 
     
    744749 
    745750        /* check whether at least one realm covers the requested url */ 
    746         for( realm = uh_realms; realm; realm = realm->next ) 
     751        for (realm = uh_realms; realm; realm = realm->next) 
    747752        { 
    748753                rlen = strlen(realm->path); 
    749754 
    750                 if( (plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen) ) 
     755                if ((plen >= rlen) && !strncasecmp(pi->name, realm->path, rlen)) 
    751756                { 
    752757                        req->realm = realm; 
     
    757762 
    758763        /* requested resource is covered by a realm */ 
    759         if( protected ) 
     764        if (protected) 
    760765        { 
    761766                /* try to get client auth info */ 
    762767                foreach_header(i, req->headers) 
    763768                { 
    764                         if( !strcasecmp(req->headers[i], "Authorization") && 
     769                        if (!strcasecmp(req->headers[i], "Authorization") && 
    765770                                (strlen(req->headers[i+1]) > 6) && 
    766                                 !strncasecmp(req->headers[i+1], "Basic ", 6) 
    767                         ) { 
     771                                !strncasecmp(req->headers[i+1], "Basic ", 6)) 
     772                        { 
    768773                                memset(buffer, 0, sizeof(buffer)); 
    769774                                uh_b64decode(buffer, sizeof(buffer) - 1, 
     
    771776                                        strlen(req->headers[i+1]) - 6); 
    772777 
    773                                 if( (pass = strchr(buffer, ':')) != NULL ) 
     778                                if ((pass = strchr(buffer, ':')) != NULL) 
    774779                                { 
    775780                                        user = buffer; 
     
    782787 
    783788                /* have client auth */ 
    784                 if( user && pass ) 
     789                if (user && pass) 
    785790                { 
    786791                        /* find matching realm */ 
    787                         for( realm = uh_realms; realm; realm = realm->next ) 
     792                        for (realm = uh_realms; realm; realm = realm->next) 
    788793                        { 
    789794                                rlen = strlen(realm->path); 
    790795 
    791                                 if( (plen >= rlen) && 
    792                                     !strncasecmp(pi->name, realm->path, rlen) && 
    793                                     !strcmp(user, realm->user) 
    794                                 ) { 
     796                                if ((plen >= rlen) && 
     797                                        !strncasecmp(pi->name, realm->path, rlen) && 
     798                                        !strcmp(user, realm->user)) 
     799                                { 
    795800                                        req->realm = realm; 
    796801                                        break; 
     
    799804 
    800805                        /* found a realm matching the username */ 
    801                         if( realm ) 
     806                        if (realm) 
    802807                        { 
    803808                                /* check user pass */ 
     
    833838        socklen_t sl; 
    834839 
    835         if( (new = (struct listener *)malloc(sizeof(struct listener))) != NULL ) 
     840        if ((new = (struct listener *)malloc(sizeof(struct listener))) != NULL) 
    836841        { 
    837842                memset(new, 0, sizeof(struct listener)); 
     
    858863        struct listener *cur = NULL; 
    859864 
    860         for( cur = uh_listeners; cur; cur = cur->next ) 
    861                 if( cur->socket == sock ) 
     865        for (cur = uh_listeners; cur; cur = cur->next) 
     866                if (cur->socket == sock) 
    862867                        return cur; 
    863868 
     
    871876        socklen_t sl; 
    872877 
    873         if( (new = (struct client *)malloc(sizeof(struct client))) != NULL ) 
     878        if ((new = (struct client *)malloc(sizeof(struct client))) != NULL) 
    874879        { 
    875880                memset(new, 0, sizeof(struct client)); 
     
    899904        struct client *cur = NULL; 
    900905 
    901         for( cur = uh_clients; cur; cur = cur->next ) 
    902                 if( cur->socket == sock ) 
     906        for (cur = uh_clients; cur; cur = cur->next) 
     907                if (cur->socket == sock) 
    903908                        return cur; 
    904909 
     
    911916        struct client *prv = NULL; 
    912917 
    913         for( cur = uh_clients; cur; prv = cur, cur = cur->next ) 
    914         { 
    915                 if( cur->socket == sock ) 
    916                 { 
    917                         if( prv ) 
     918        for (cur = uh_clients; cur; prv = cur, cur = cur->next) 
     919        { 
     920                if (cur->socket == sock) 
     921                { 
     922                        if (prv) 
    918923                                prv->next = cur->next; 
    919924                        else 
     
    934939        struct interpreter *new = NULL; 
    935940 
    936         if( (new = (struct interpreter *) 
    937                         malloc(sizeof(struct interpreter))) != NULL ) 
     941        if ((new = (struct interpreter *)malloc(sizeof(struct interpreter))) != NULL) 
    938942        { 
    939943                memset(new, 0, sizeof(struct interpreter)); 
     
    956960        const char *e; 
    957961 
    958         for( cur = uh_interpreters; cur; cur = cur->next ) 
     962        for (cur = uh_interpreters; cur; cur = cur->next) 
    959963        { 
    960964                e = &path[max(strlen(path) - strlen(cur->extn), 0)]; 
    961965 
    962                 if( !strcmp(e, cur->extn) ) 
     966                if (!strcmp(e, cur->extn)) 
    963967                        return cur; 
    964968        } 
  • trunk/package/uhttpd/src/uhttpd.c

    r31571 r31572  
    4545static void uh_sigchld(int sig) 
    4646{ 
    47         while( waitpid(-1, NULL, WNOHANG) > 0 ) { } 
     47        while (waitpid(-1, NULL, WNOHANG) > 0) { } 
    4848} 
    4949 
     
    5959 
    6060 
    61         if( (c = fopen(path, "r")) != NULL ) 
     61        if ((c = fopen(path, "r")) != NULL) 
    6262        { 
    6363                memset(line, 0, sizeof(line)); 
    6464 
    65                 while( fgets(line, sizeof(line) - 1, c) ) 
    66                 { 
    67                         if( (line[0] == '/') && (strchr(line, ':') != NULL) ) 
    68                         { 
    69                                 if( !(col1 = strchr(line, ':')) || (*col1++ = 0) || 
     65                while (fgets(line, sizeof(line) - 1, c)) 
     66                { 
     67                        if ((line[0] == '/') && (strchr(line, ':') != NULL)) 
     68                        { 
     69                                if (!(col1 = strchr(line, ':')) || (*col1++ = 0) || 
    7070                                    !(col2 = strchr(col1, ':')) || (*col2++ = 0) || 
    71                                         !(eol = strchr(col2, '\n')) || (*eol++  = 0) ) 
    72                                                 continue; 
    73  
    74                                 if( !uh_auth_add(line, col1, col2) ) 
     71                                        !(eol = strchr(col2, '\n')) || (*eol++  = 0)) 
     72                                { 
     73                                        continue; 
     74                                } 
     75 
     76                                if (!uh_auth_add(line, col1, col2)) 
    7577                                { 
    7678                                        fprintf(stderr, 
    77                                                 "Notice: No password set for user %s, ignoring " 
    78                                                 "authentication on %s\n", col1, line 
     79                                                        "Notice: No password set for user %s, ignoring " 
     80                                                        "authentication on %s\n", col1, line 
    7981                                        ); 
    8082                                } 
    8183                        } 
    82                         else if( !strncmp(line, "I:", 2) ) 
    83                         { 
    84                                 if( !(col1 = strchr(line, ':')) || (*col1++ = 0) || 
    85                                     !(eol = strchr(col1, '\n')) || (*eol++  = 0) ) 
    86                                         continue; 
     84                        else if (!strncmp(line, "I:", 2)) 
     85                        { 
     86                                if (!(col1 = strchr(line, ':')) || (*col1++ = 0) || 
     87                                    !(eol = strchr(col1, '\n')) || (*eol++  = 0)) 
     88                                { 
     89                                        continue; 
     90                                } 
    8791 
    8892                                conf->index_file = strdup(col1); 
    8993                        } 
    90                         else if( !strncmp(line, "E404:", 5) ) 
    91                         { 
    92                                 if( !(col1 = strchr(line, ':')) || (*col1++ = 0) || 
    93                                     !(eol = strchr(col1, '\n')) || (*eol++  = 0) ) 
    94                                                 continue; 
     94                        else if (!strncmp(line, "E404:", 5)) 
     95                        { 
     96                                if (!(col1 = strchr(line, ':')) || (*col1++ = 0) || 
     97                                    !(eol = strchr(col1, '\n')) || (*eol++  = 0)) 
     98                                { 
     99                                        continue; 
     100                                } 
    95101 
    96102                                conf->error_handler = strdup(col1); 
    97103                        } 
    98104#ifdef HAVE_CGI 
    99                         else if( (line[0] == '*') && (strchr(line, ':') != NULL) ) 
    100                         { 
    101                                 if( !(col1 = strchr(line, '*')) || (*col1++ = 0) || 
     105                        else if ((line[0] == '*') && (strchr(line, ':') != NULL)) 
     106                        { 
     107                                if (!(col1 = strchr(line, '*')) || (*col1++ = 0) || 
    102108                                    !(col2 = strchr(col1, ':')) || (*col2++ = 0) || 
    103                                     !(eol = strchr(col2, '\n')) || (*eol++  = 0) ) 
    104                                                 continue; 
    105  
    106                                 if( !uh_interpreter_add(col1, col2) ) 
     109                                    !(eol = strchr(col2, '\n')) || (*eol++  = 0)) 
     110                                { 
     111                                        continue; 
     112                                } 
     113 
     114                                if (!uh_interpreter_add(col1, col2)) 
    107115                                { 
    108116                                        fprintf(stderr, 
    109                                                 "Unable to add interpreter %s for extension %s: " 
    110                                                 "Out of memory\n", col2, col1 
     117                                                        "Unable to add interpreter %s for extension %s: " 
     118                                                        "Out of memory\n", col2, col1 
    111119                                        ); 
    112120                                } 
     
    119127} 
    120128 
    121 static int uh_socket_bind( 
    122         fd_set *serv_fds, int *max_fd, const char *host, const char *port, 
    123         struct addrinfo *hints, int do_tls, struct config *conf 
    124 ) { 
     129static int uh_socket_bind(fd_set *serv_fds, int *max_fd, 
     130                                                  const char *host, const char *port, 
     131                                                  struct addrinfo *hints, int do_tls, 
     132                                                  struct config *conf) 
     133{ 
    125134        int sock = -1; 
    126135        int yes = 1; 
     
    133142        struct addrinfo *addrs = NULL, *p = NULL; 
    134143 
    135         if( (status = getaddrinfo(host, port, hints, &addrs)) != 0 ) 
     144        if ((status = getaddrinfo(host, port, hints, &addrs)) != 0) 
    136145        { 
    137146                fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(status)); 
     
    139148 
    140149        /* try to bind a new socket to each found address */ 
    141         for( p = addrs; p; p = p->ai_next ) 
     150        for (p = addrs; p; p = p->ai_next) 
    142151        { 
    143152                /* get the socket */ 
    144                 if( (sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1 ) 
     153                if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
    145154                { 
    146155                        perror("socket()"); 
     
    149158 
    150159                /* "address already in use" */ 
    151                 if( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) ) 
     160                if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) 
    152161                { 
    153162                        perror("setsockopt()"); 
     
    156165 
    157166                /* TCP keep-alive */ 
    158                 if( conf->tcp_keepalive > 0 ) 
     167                if (conf->tcp_keepalive > 0) 
    159168                { 
    160169                        tcp_ka_idl = 1; 
     
    162171                        tcp_ka_int = conf->tcp_keepalive; 
    163172 
    164                         if( setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) || 
     173                        if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) || 
    165174                            setsockopt(sock, SOL_TCP, TCP_KEEPIDLE,  &tcp_ka_idl, sizeof(tcp_ka_idl)) || 
    166175                            setsockopt(sock, SOL_TCP, TCP_KEEPINTVL, &tcp_ka_int, sizeof(tcp_ka_int)) || 
    167                             setsockopt(sock, SOL_TCP, TCP_KEEPCNT,   &tcp_ka_cnt, sizeof(tcp_ka_cnt)) ) 
     176                            setsockopt(sock, SOL_TCP, TCP_KEEPCNT,   &tcp_ka_cnt, sizeof(tcp_ka_cnt))) 
    168177                        { 
    169178                            fprintf(stderr, "Notice: Unable to enable TCP keep-alive: %s\n", 
     
    173182 
    174183                /* required to get parallel v4 + v6 working */ 
    175                 if( p->ai_family == AF_INET6 ) 
    176                 { 
    177                         if( setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes)) == -1 ) 
     184                if (p->ai_family == AF_INET6) 
     185                { 
     186                        if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes)) == -1) 
    178187                        { 
    179188                                perror("setsockopt()"); 
     
    183192 
    184193                /* bind */ 
    185                 if( bind(sock, p->ai_addr, p->ai_addrlen) == -1 ) 
     194                if (bind(sock, p->ai_addr, p->ai_addrlen) == -1) 
    186195                { 
    187196                        perror("bind()"); 
     
    190199 
    191200                /* listen */ 
    192                 if( listen(sock, UH_LIMIT_CLIENTS) == -1 ) 
     201                if (listen(sock, UH_LIMIT_CLIENTS) == -1) 
    193202                { 
    194203                        perror("listen()"); 
     
    197206 
    198207                /* add listener to global list */ 
    199                 if( ! (l = uh_listener_add(sock, conf)) ) 
     208                if (!(l = uh_listener_add(sock, conf))) 
    200209                { 
    201210                        fprintf(stderr, "uh_listener_add(): Failed to allocate memory\n"); 
     
    217226 
    218227                error: 
    219                 if( sock > 0 ) 
     228                if (sock > 0) 
    220229                        close(sock); 
    221230        } 
     
    226235} 
    227236 
    228 static struct http_request * uh_http_header_parse(struct client *cl, char *buffer, int buflen) 
     237static struct http_request * uh_http_header_parse(struct client *cl, 
     238                                                                                                  char *buffer, int buflen) 
    229239{ 
    230240        char *method  = &buffer[0]; 
     
    245255 
    246256        /* terminate initial header line */ 
    247         if( (headers = strfind(buffer, buflen, "\r\n", 2)) != NULL ) 
     257        if ((headers = strfind(buffer, buflen, "\r\n", 2)) != NULL) 
    248258        { 
    249259                buffer[buflen-1] = 0; 
     
    253263 
    254264                /* find request path */ 
    255                 if( (path = strchr(buffer, ' ')) != NULL ) 
     265                if ((path = strchr(buffer, ' ')) != NULL) 
    256266                        *path++ = 0; 
    257267 
    258268                /* find http version */ 
    259                 if( (path != NULL) && ((version = strchr(path, ' ')) != NULL) ) 
     269                if ((path != NULL) && ((version = strchr(path, ' ')) != NULL)) 
    260270                        *version++ = 0; 
    261271 
    262272 
    263273                /* check method */ 
    264                 if( strcmp(method, "GET") && strcmp(method, "HEAD") && strcmp(method, "POST") ) 
     274                if (strcmp(method, "GET") && strcmp(method, "HEAD") && strcmp(method, "POST")) 
    265275                { 
    266276                        /* invalid method */ 
     
    287297 
    288298                /* check path */ 
    289                 if( !path || !strlen(path) ) 
     299                if (!path || !strlen(path)) 
    290300                { 
    291301                        /* malformed request */ 
     
    299309 
    300310                /* check version */ 
    301                 if( (version == NULL) || (strcmp(version, "HTTP/0.9") && 
    302                     strcmp(version, "HTTP/1.0") && strcmp(version, "HTTP/1.1")) ) 
     311                if ((version == NULL) || (strcmp(version, "HTTP/0.9") && 
     312                    strcmp(version, "HTTP/1.0") && strcmp(version, "HTTP/1.1"))) 
    303313                { 
    304314                        /* unsupported version */ 
     
    313323 
    314324                /* process header fields */ 
    315                 for( i = (int)(headers - buffer); i < buflen; i++ ) 
     325                for (i = (int)(headers - buffer); i < buflen; i++) 
    316326                { 
    317327                        /* found eol and have name + value, push out header tuple */ 
    318                         if( hdrname && hdrdata && (buffer[i] == '\r' || buffer[i] == '\n') ) 
     328                        if (hdrname && hdrdata && (buffer[i] == '\r' || buffer[i] == '\n')) 
    319329                        { 
    320330                                buffer[i] = 0; 
    321331 
    322332                                /* store */ 
    323                                 if( (hdrcount + 1) < array_size(req.headers) ) 
     333                                if ((hdrcount + 1) < array_size(req.headers)) 
    324334                                { 
    325335                                        req.headers[hdrcount++] = hdrname; 
     
    338348 
    339349                        /* have name but no value and found a colon, start of value */ 
    340                         else if( hdrname && !hdrdata && 
    341                             ((i+1) < buflen) && (buffer[i] == ':') 
    342                         ) { 
     350                        else if (hdrname && !hdrdata && 
     351                                         ((i+1) < buflen) && (buffer[i] == ':')) 
     352                        { 
    343353                                buffer[i] = 0; 
    344354                                hdrdata = &buffer[i+1]; 
     
    349359 
    350360                        /* have no name and found [A-Za-z], start of name */ 
    351                         else if( !hdrname && isalpha(buffer[i]) ) 
     361                        else if (!hdrname && isalpha(buffer[i])) 
    352362                        { 
    353363                                hdrname = &buffer[i]; 
     
    381391        memset(buffer, 0, sizeof(buffer)); 
    382392 
    383         while( blen > 0 ) 
     393        while (blen > 0) 
    384394        { 
    385395                FD_ZERO(&reader); 
     
    391401 
    392402                /* check whether fd is readable */ 
    393                 if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 ) 
     403                if (select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0) 
    394404                { 
    395405                        /* receive data */ 
    396406                        ensure_out(rlen = uh_tcp_peek(cl, bufptr, blen)); 
    397407 
    398                         if( (idxptr = strfind(buffer, sizeof(buffer), "\r\n\r\n", 4)) ) 
     408                        if ((idxptr = strfind(buffer, sizeof(buffer), "\r\n\r\n", 4))) 
    399409                        { 
    400410                                ensure_out(rlen = uh_tcp_recv(cl, bufptr, 
     
    411421 
    412422                                /* unexpected eof - #7904 */ 
    413                                 if( rlen == 0 ) 
     423                                if (rlen == 0) 
    414424                                        return NULL; 
    415425 
     
    435445static int uh_path_match(const char *prefix, const char *url) 
    436446{ 
    437         if( (strstr(url, prefix) == url) && 
    438             ((prefix[strlen(prefix)-1] == '/') || 
     447        if ((strstr(url, prefix) == url) && 
     448                ((prefix[strlen(prefix)-1] == '/') || 
    439449                 (strlen(url) == strlen(prefix))   || 
    440                  (url[strlen(prefix)] == '/')) 
    441         ) { 
     450                 (url[strlen(prefix)] == '/'))) 
     451        { 
    442452                return 1; 
    443453        } 
     
    447457#endif 
    448458 
    449 static void uh_dispatch_request( 
    450         struct client *cl, struct http_request *req, struct path_info *pin 
    451 ) { 
     459static void uh_dispatch_request(struct client *cl, struct http_request *req, 
     460                                                                struct path_info *pin) 
     461{ 
    452462#ifdef HAVE_CGI 
    453463        struct interpreter *ipr = NULL; 
    454464 
    455         if( uh_path_match(cl->server->conf->cgi_prefix, pin->name) || 
    456                 (ipr = uh_interpreter_lookup(pin->phys)) ) 
     465        if (uh_path_match(cl->server->conf->cgi_prefix, pin->name) || 
     466                (ipr = uh_interpreter_lookup(pin->phys))) 
    457467        { 
    458468                uh_cgi_request(cl, req, pin, ipr); 
     
    486496 
    487497        /* loop */ 
    488         while(run) 
     498        while (run) 
    489499        { 
    490500                /* create a working copy of the used fd set */ 
     
    492502 
    493503                /* sleep until socket activity */ 
    494                 if( select(max_fd + 1, &read_fds, NULL, NULL, NULL) == -1 ) 
     504                if (select(max_fd + 1, &read_fds, NULL, NULL, NULL) == -1) 
    495505                { 
    496506                        perror("select()"); 
     
    499509 
    500510                /* run through the existing connections looking for data to be read */ 
    501                 for( cur_fd = 0; cur_fd <= max_fd; cur_fd++ ) 
     511                for (cur_fd = 0; cur_fd <= max_fd; cur_fd++) 
    502512                { 
    503513                        /* is a socket managed by us */ 
    504                         if( FD_ISSET(cur_fd, &read_fds) ) 
     514                        if (FD_ISSET(cur_fd, &read_fds)) 
    505515                        { 
    506516                                /* is one of our listen sockets */ 
    507                                 if( FD_ISSET(cur_fd, &serv_fds) ) 
     517                                if (FD_ISSET(cur_fd, &serv_fds)) 
    508518                                { 
    509519                                        /* handle new connections */ 
    510                                         if( (new_fd = accept(cur_fd, NULL, 0)) != -1 ) 
     520                                        if ((new_fd = accept(cur_fd, NULL, 0)) != -1) 
    511521                                        { 
    512522                                                /* add to global client list */ 
    513                                                 if( (cl = uh_client_add(new_fd, uh_listener_lookup(cur_fd))) != NULL ) 
     523                                                if ((cl = uh_client_add(new_fd, uh_listener_lookup(cur_fd))) != NULL) 
    514524                                                { 
    515525#ifdef HAVE_TLS 
    516526                                                        /* setup client tls context */ 
    517                                                         if( conf->tls ) 
     527                                                        if (conf->tls) 
    518528                                                        { 
    519                                                                 if( conf->tls_accept(cl) < 1 ) 
     529                                                                if (conf->tls_accept(cl) < 1) 
    520530                                                                { 
    521531                                                                        fprintf(stderr, 
    522                                                                                 "tls_accept failed, " 
    523                                                                                 "connection dropped\n"); 
     532                                                                                        "tls_accept failed, " 
     533                                                                                        "connection dropped\n"); 
    524534 
    525535                                                                        /* close client socket */ 
     
    544554                                                { 
    545555                                                        fprintf(stderr, 
    546                                                                 "uh_client_add(): Cannot allocate memory\n"); 
     556                                                                        "uh_client_add(): " 
     557                                                                        "Cannot allocate memory\n"); 
    547558 
    548559                                                        close(new_fd); 
     
    554565                                else 
    555566                                { 
    556                                         if( ! (cl = uh_client_lookup(cur_fd)) ) 
     567                                        if (!(cl = uh_client_lookup(cur_fd))) 
    557568                                        { 
    558569                                                /* this should not happen! */ 
    559570                                                fprintf(stderr, 
    560                                                         "uh_client_lookup(): No entry for fd %i!\n", 
    561                                                         cur_fd); 
     571                                                                "uh_client_lookup(): No entry for fd %i!\n", 
     572                                                                cur_fd); 
    562573 
    563574                                                goto cleanup; 
     
    565576 
    566577                                        /* parse message header */ 
    567                                         if( (req = uh_http_header_recv(cl)) != NULL ) 
     578                                        if ((req = uh_http_header_recv(cl)) != NULL) 
    568579                                        { 
    569580                                                /* RFC1918 filtering required? */ 
    570                                                 if( conf->rfc1918_filter && 
     581                                                if (conf->rfc1918_filter && 
    571582                                                    sa_rfc1918(&cl->peeraddr) && 
    572                                                     !sa_rfc1918(&cl->servaddr) ) 
     583                                                    !sa_rfc1918(&cl->servaddr)) 
    573584                                                { 
    574585                                                        uh_http_sendhf(cl, 403, "Forbidden", 
    575                                                                 "Rejected request from RFC1918 IP " 
    576                                                                 "to public server address"); 
     586                                                                                   "Rejected request from RFC1918 IP " 
     587                                                                                   "to public server address"); 
    577588                                                } 
    578589                                                else 
    579590#ifdef HAVE_LUA 
    580591                                                /* Lua request? */ 
    581                                                 if( conf->lua_state && 
    582                                                     uh_path_match(conf->lua_prefix, req->url) ) 
     592                                                if (conf->lua_state && 
     593                                                        uh_path_match(conf->lua_prefix, req->url)) 
    583594                                                { 
    584595                                                        conf->lua_request(cl, req, conf->lua_state); 
     
    587598#endif 
    588599                                                /* dispatch request */ 
    589                                                 if( (pin = uh_path_lookup(cl, req->url)) != NULL ) 
     600                                                if ((pin = uh_path_lookup(cl, req->url)) != NULL) 
    590601                                                { 
    591602                                                        /* auth ok? */ 
    592                                                         if( !pin->redirected && uh_auth_check(cl, req, pin) ) 
     603                                                        if (!pin->redirected && uh_auth_check(cl, req, pin)) 
    593604                                                                uh_dispatch_request(cl, req, pin); 
    594605                                                } 
     
    600611                                                        pin = uh_path_lookup(cl, conf->error_handler); 
    601612 
    602                                                         if( pin && uh_auth_check(cl, req, pin) ) 
     613                                                        if (pin && uh_auth_check(cl, req, pin)) 
    603614                                                        { 
    604615                                                                req->redirect_status = 404; 
     
    615626#ifdef HAVE_TLS 
    616627                                        /* free client tls context */ 
    617                                         if( conf->tls ) 
     628                                        if (conf->tls) 
    618629                                                conf->tls_close(cl); 
    619630#endif 
     
    634645#ifdef HAVE_LUA 
    635646        /* destroy the Lua state */ 
    636         if( conf->lua_state != NULL ) 
     647        if (conf->lua_state != NULL) 
    637648                conf->lua_close(conf->lua_state); 
    638649#endif 
     
    646657 
    647658        /* already loaded */ 
    648         if( conf->tls != NULL ) 
     659        if (conf->tls != NULL) 
    649660                return 0; 
    650661 
    651662        /* load TLS plugin */ 
    652         if( ! (lib = dlopen("uhttpd_tls.so", RTLD_LAZY | RTLD_GLOBAL)) ) 
     663        if (!(lib = dlopen("uhttpd_tls.so", RTLD_LAZY | RTLD_GLOBAL))) 
    653664        { 
    654665                fprintf(stderr, 
    655                         "Notice: Unable to load TLS plugin - disabling SSL support! " 
    656                         "(Reason: %s)\n", dlerror() 
     666                                "Notice: Unable to load TLS plugin - disabling SSL support! " 
     667                                "(Reason: %s)\n", dlerror() 
    657668                ); 
    658669 
     
    662673        { 
    663674                /* resolve functions */ 
    664                 if( !(conf->tls_init   = dlsym(lib, "uh_tls_ctx_init"))      || 
     675                if (!(conf->tls_init   = dlsym(lib, "uh_tls_ctx_init"))      || 
    665676                    !(conf->tls_cert   = dlsym(lib, "uh_tls_ctx_cert"))      || 
    666677                    !(conf->tls_key    = dlsym(lib, "uh_tls_ctx_key"))       || 
     
    669680                    !(conf->tls_close  = dlsym(lib, "uh_tls_client_close"))  || 
    670681                    !(conf->tls_recv   = dlsym(lib, "uh_tls_client_recv"))   || 
    671                     !(conf->tls_send   = dlsym(lib, "uh_tls_client_send")) 
    672                 ) { 
     682                    !(conf->tls_send   = dlsym(lib, "uh_tls_client_send"))) 
     683                { 
    673684                        fprintf(stderr, 
    674                                 "Error: Failed to lookup required symbols " 
    675                                 "in TLS plugin: %s\n", dlerror() 
     685                                        "Error: Failed to lookup required symbols " 
     686                                        "in TLS plugin: %s\n", dlerror() 
    676687                        ); 
    677688                        exit(1); 
     
    679690 
    680691                /* init SSL context */ 
    681                 if( ! (conf->tls = conf->tls_init()) ) 
     692                if (!(conf->tls = conf->tls_init())) 
    682693                { 
    683694                        fprintf(stderr, "Error: Failed to initalize SSL context\n"); 
     
    756767 
    757768 
    758         while( (opt = getopt(argc, argv, 
    759                 "fSDRC:K:E:I:p:s:h:c:l:L:d:r:m:x:i:t:T:A:")) > 0 
    760         ) { 
     769        while ((opt = getopt(argc, argv, 
     770                                                 "fSDRC:K:E:I:p:s:h:c:l:L:d:r:m:x:i:t:T:A:")) > 0) 
     771        { 
    761772                switch(opt) 
    762773                { 
     
    764775                        case 'p': 
    765776                        case 's': 
    766                                 if( (port = strrchr(optarg, ':')) != NULL ) 
    767                                 { 
    768                                         if( (optarg[0] == '[') && (port > optarg) && (port[-1] == ']') ) 
     777                                if ((port = strrchr(optarg, ':')) != NULL) 
     778                                { 
     779                                        if ((optarg[0] == '[') && (port > optarg) && (port[-1] == ']')) 
    769780                                                memcpy(bind, optarg + 1, 
    770781                                                        min(sizeof(bind), (int)(port - optarg) - 2)); 
     
    781792 
    782793#ifdef HAVE_TLS 
    783                                 if( opt == 's' ) 
    784                                 { 
    785                                         if( uh_inittls(&conf) ) 
     794                                if (opt == 's') 
     795                                { 
     796                                        if (uh_inittls(&conf)) 
    786797                                        { 
    787798                                                fprintf(stderr, 
     
    797808 
    798809                                /* bind sockets */ 
    799                                 bound += uh_socket_bind( 
    800                                         &serv_fds, &max_fd, bind[0] ? bind : NULL, port, 
    801                                         &hints, (opt == 's'), &conf 
    802                                 ); 
     810                                bound += uh_socket_bind(&serv_fds, &max_fd, 
     811                                                                                bind[0] ? bind : NULL, 
     812                                                                                port, &hints, (opt == 's'), &conf); 
    803813 
    804814                                memset(bind, 0, sizeof(bind)); 
     
    808818                        /* certificate */ 
    809819                        case 'C': 
    810                                 if( !uh_inittls(&conf) ) 
    811                                 { 
    812                                         if( conf.tls_cert(conf.tls, optarg) < 1 ) 
     820                                if (!uh_inittls(&conf)) 
     821                                { 
     822                                        if (conf.tls_cert(conf.tls, optarg) < 1) 
    813823                                        { 
    814824                                                fprintf(stderr, 
    815                                                         "Error: Invalid certificate file given\n"); 
     825                                                                "Error: Invalid certificate file given\n"); 
    816826                                                exit(1); 
    817827                                        } 
     
    824834                        /* key */ 
    825835                        case 'K': 
    826                                 if( !uh_inittls(&conf) ) 
    827                                 { 
    828                                         if( conf.tls_key(conf.tls, optarg) < 1 ) 
     836                                if (!uh_inittls(&conf)) 
     837                                { 
     838                                        if (conf.tls_key(conf.tls, optarg) < 1) 
    829839                                        { 
    830840                                                fprintf(stderr, 
    831                                                         "Error: Invalid private key file given\n"); 
     841                                                                "Error: Invalid private key file given\n"); 
    832842                                                exit(1); 
    833843                                        } 
     
    841851                        /* docroot */ 
    842852                        case 'h': 
    843                                 if( ! realpath(optarg, conf.docroot) ) 
     853                                if (! realpath(optarg, conf.docroot)) 
    844854                                { 
    845855                                        fprintf(stderr, "Error: Invalid directory %s: %s\n", 
    846                                                 optarg, strerror(errno)); 
     856                                                        optarg, strerror(errno)); 
    847857                                        exit(1); 
    848858                                } 
     
    851861                        /* error handler */ 
    852862                        case 'E': 
    853                                 if( (strlen(optarg) == 0) || (optarg[0] != '/') ) 
     863                                if ((strlen(optarg) == 0) || (optarg[0] != '/')) 
    854864                                { 
    855865                                        fprintf(stderr, "Error: Invalid error handler: %s\n", 
    856                                                 optarg); 
     866                                                        optarg); 
    857867                                        exit(1); 
    858868                                } 
     
    862872                        /* index file */ 
    863873                        case 'I': 
    864                                 if( (strlen(optarg) == 0) || (optarg[0] == '/') ) 
     874                                if ((strlen(optarg) == 0) || (optarg[0] == '/')) 
    865875                                { 
    866876                                        fprintf(stderr, "Error: Invalid index page: %s\n", 
    867                                                 optarg); 
     877                                                        optarg); 
    868878                                        exit(1); 
    869879                                } 
     
    893903                        /* interpreter */ 
    894904                        case 'i': 
    895                                 if( (optarg[0] == '.') && (port = strchr(optarg, '=')) ) 
     905                                if ((optarg[0] == '.') && (port = strchr(optarg, '='))) 
    896906                                { 
    897907                                        *port++ = 0; 
     
    901911                                { 
    902912                                        fprintf(stderr, "Error: Invalid interpreter: %s\n", 
    903                                                 optarg); 
     913                                                        optarg); 
    904914                                        exit(1); 
    905915                                } 
     
    943953                        /* urldecode */ 
    944954                        case 'd': 
    945                                 if( (port = malloc(strlen(optarg)+1)) != NULL ) 
     955                                if ((port = malloc(strlen(optarg)+1)) != NULL) 
    946956                                { 
    947957                                        /* "decode" plus to space to retain compat */ 
     
    952962                                        memset(port, 0, opt+1); 
    953963                                        if (uh_urldecode(port, opt, optarg, opt) < 0) 
    954                                             fprintf( stderr, "uhttpd: invalid encoding\n" ); 
     964                                            fprintf(stderr, "uhttpd: invalid encoding\n"); 
    955965 
    956966                                        printf("%s", port); 
     
    10161026 
    10171027#ifdef HAVE_TLS 
    1018         if( (tls == 1) && (keys < 2) ) 
     1028        if ((tls == 1) && (keys < 2)) 
    10191029        { 
    10201030                fprintf(stderr, "Error: Missing private key or certificate file\n"); 
     
    10231033#endif 
    10241034 
    1025         if( bound < 1 ) 
     1035        if (bound < 1) 
    10261036        { 
    10271037                fprintf(stderr, "Error: No sockets bound, unable to continue\n"); 
     
    10301040 
    10311041        /* default docroot */ 
    1032         if( !conf.docroot[0] && !realpath(".", conf.docroot) ) 
     1042        if (!conf.docroot[0] && !realpath(".", conf.docroot)) 
    10331043        { 
    10341044                fprintf(stderr, "Error: Can not determine default document root: %s\n", 
     
    10381048 
    10391049        /* default realm */ 
    1040         if( ! conf.realm ) 
     1050        if (!conf.realm) 
    10411051                conf.realm = "Protected Area"; 
    10421052 
     
    10451055 
    10461056        /* default network timeout */ 
    1047         if( conf.network_timeout <= 0 ) 
     1057        if (conf.network_timeout <= 0) 
    10481058                conf.network_timeout = 30; 
    10491059 
    10501060#if defined(HAVE_CGI) || defined(HAVE_LUA) 
    10511061        /* default script timeout */ 
    1052         if( conf.script_timeout <= 0 ) 
     1062        if (conf.script_timeout <= 0) 
    10531063                conf.script_timeout = 60; 
    10541064#endif 
     
    10561066#ifdef HAVE_CGI 
    10571067        /* default cgi prefix */ 
    1058         if( ! conf.cgi_prefix ) 
     1068        if (!conf.cgi_prefix) 
    10591069                conf.cgi_prefix = "/cgi-bin"; 
    10601070#endif 
     
    10621072#ifdef HAVE_LUA 
    10631073        /* load Lua plugin */ 
    1064         if( ! (lib = dlopen("uhttpd_lua.so", RTLD_LAZY | RTLD_GLOBAL)) ) 
     1074        if (!(lib = dlopen("uhttpd_lua.so", RTLD_LAZY | RTLD_GLOBAL))) 
    10651075        { 
    10661076                fprintf(stderr, 
    1067                         "Notice: Unable to load Lua plugin - disabling Lua support! " 
    1068                         "(Reason: %s)\n", dlerror() 
    1069                 ); 
     1077                                "Notice: Unable to load Lua plugin - disabling Lua support! " 
     1078                                "(Reason: %s)\n", dlerror()); 
    10701079        } 
    10711080        else 
    10721081        { 
    10731082                /* resolve functions */ 
    1074                 if( !(conf.lua_init    = dlsym(lib, "uh_lua_init"))    || 
     1083                if (!(conf.lua_init    = dlsym(lib, "uh_lua_init"))    || 
    10751084                    !(conf.lua_close   = dlsym(lib, "uh_lua_close"))   || 
    1076                     !(conf.lua_request = dlsym(lib, "uh_lua_request")) 
    1077                 ) { 
     1085                    !(conf.lua_request = dlsym(lib, "uh_lua_request"))) 
     1086                { 
    10781087                        fprintf(stderr, 
    1079                                 "Error: Failed to lookup required symbols " 
    1080                                 "in Lua plugin: %s\n", dlerror() 
     1088                                        "Error: Failed to lookup required symbols " 
     1089                                        "in Lua plugin: %s\n", dlerror() 
    10811090                        ); 
    10821091                        exit(1); 
     
    10841093 
    10851094                /* init Lua runtime if handler is specified */ 
    1086                 if( conf.lua_handler ) 
     1095                if (conf.lua_handler) 
    10871096                { 
    10881097                        /* default lua prefix */ 
    1089                         if( ! conf.lua_prefix ) 
     1098                        if (!conf.lua_prefix) 
    10901099                                conf.lua_prefix = "/lua"; 
    10911100 
     
    10961105 
    10971106        /* fork (if not disabled) */ 
    1098         if( ! nofork ) 
    1099         { 
    1100                 switch( fork() ) 
     1107        if (!nofork) 
     1108        { 
     1109                switch (fork()) 
    11011110                { 
    11021111                        case -1: 
     
    11061115                        case 0: 
    11071116                                /* daemon setup */ 
    1108                                 if( chdir("/") ) 
     1117                                if (chdir("/")) 
    11091118                                        perror("chdir()"); 
    11101119 
    1111                                 if( (cur_fd = open("/dev/null", O_WRONLY)) > -1 ) 
     1120                                if ((cur_fd = open("/dev/null", O_WRONLY)) > -1) 
    11121121                                        dup2(cur_fd, 0); 
    11131122 
    1114                                 if( (cur_fd = open("/dev/null", O_RDONLY)) > -1 ) 
     1123                                if ((cur_fd = open("/dev/null", O_RDONLY)) > -1) 
    11151124                                        dup2(cur_fd, 1); 
    11161125 
    1117                                 if( (cur_fd = open("/dev/null", O_RDONLY)) > -1 ) 
     1126                                if ((cur_fd = open("/dev/null", O_RDONLY)) > -1) 
    11181127                                        dup2(cur_fd, 2); 
    11191128 
     
    11301139#ifdef HAVE_LUA 
    11311140        /* destroy the Lua state */ 
    1132         if( conf.lua_state != NULL ) 
     1141        if (conf.lua_state != NULL) 
    11331142                conf.lua_close(conf.lua_state); 
    11341143#endif 
Note: See TracChangeset for help on using the changeset viewer.