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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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        } 
Note: See TracChangeset for help on using the changeset viewer.