Changeset 405

Show
Ignore:
Timestamp:
09/16/06 18:42:11 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r324 r405  
     12006-09-16  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/util.c (cherokee_estimate_va_length): Performance 
     4        improvement. Speeded up about 13,35%. 
     5 
     62006-0x-xx  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     7 
     8        * Loads of commits.. 
     9 
    1102006-07-05  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    211 

  • cherokee/trunk/cherokee/buffer.c

    r404 r405  
    130130 
    131131        n->buf = (char *) malloc(buf->len + 1); 
    132         if (unlikely(n->buf == NULL)) return ret_nomem; 
     132        if (unlikely (n->buf == NULL)) return ret_nomem; 
    133133 
    134134        memcpy (n->buf, buf->buf, buf->len + 1); 
    …… 
    147147        int free = buf->size - buf->len; 
    148148 
    149         if (size <= 0) 
     149        if (unlikely (size <= 0)) 
    150150                return ret_ok; 
    151151 
    …… 
    154154        if (free < (size+1)) { 
    155155                buf->buf = (char *) realloc(buf->buf, buf->size + size - free + 1); 
    156                 return_if_fail (buf->buf, ret_nomem); 
     156                if (unlikely (buf->buf == NULL))  
     157                        return ret_nomem; 
    157158 
    158159                buf->size += size - free + 1; 
    …… 
    191192        len = vsnprintf (buf->buf + buf->len, buf->size - buf->len -1, format, args2); 
    192193         
    193 #if 1 
     194#if 0 
    194195        if (estimated_length < len) 
    195196                PRINT_ERROR ("  -> '%s' -> '%s', esti=%d real=%d\n",  
    …… 
    197198#endif 
    198199 
    199         if (len < 0) return ret_error; 
     200        if (unlikely (len < 0))  
     201                return ret_error; 
    200202 
    201203        buf->len += len; 

  • cherokee/trunk/cherokee/header.c

    r358 r405  
    262262parse_method (cherokee_header_t *hdr, char *line, char **pointer) 
    263263{ 
    264         /* These are HTTP/1.1 methods 
    265          */ 
    266         if (cmp_str (line, "GET ")) { 
    267                 hdr->method = http_get; 
    268                 *pointer += 4; 
    269                 return ret_ok; 
    270         } else if (cmp_str (line, "POST ")) { 
    271                 hdr->method = http_post; 
    272                 *pointer += 5; 
    273                 return ret_ok; 
    274         } else if (cmp_str (line, "HEAD ")) { 
    275                 hdr->method = http_head; 
    276                 *pointer += 5; 
    277                 return ret_ok; 
    278         } else if (cmp_str (line, "OPTIONS ")) { 
    279                 hdr->method = http_options; 
    280                 *pointer += 8; 
    281                 return ret_ok; 
    282         } else if (cmp_str (line, "PUT ")) { 
    283                 hdr->method = http_put; 
    284                 *pointer += 4; 
    285                 return ret_ok; 
    286         } else if (cmp_str (line, "DELETE ")) { 
    287                 hdr->method = http_delete; 
    288                 *pointer += 7; 
    289                 return ret_ok; 
    290         } else if (cmp_str (line, "TRACE ")) { 
    291                 hdr->method = http_trace; 
    292                 *pointer += 6; 
    293                 return ret_ok; 
    294         } else if (cmp_str (line, "CONNECT ")) { 
    295                 hdr->method = http_connect; 
    296                 *pointer += 8; 
    297                 return ret_ok; 
    298  
    299         /* WebDAV methods 
    300          */ 
    301         } else if (cmp_str (line, "COPY ")) { 
    302                 hdr->method = http_copy; 
    303                 *pointer += 5; 
    304                 return ret_ok; 
    305         } else if (cmp_str (line, "LOCK ")) { 
    306                 hdr->method = http_lock; 
    307                 *pointer += 5; 
    308                 return ret_ok; 
    309         } else if (cmp_str (line, "MKCOL ")) { 
    310                 hdr->method = http_mkcol; 
    311                 *pointer += 6; 
    312                 return ret_ok; 
    313         } else if (cmp_str (line, "MOVE ")) { 
    314                 hdr->method = http_move; 
    315                 *pointer += 5; 
    316                 return ret_ok; 
    317         } else if (cmp_str (line, "NOTIFY ")) { 
    318                 hdr->method = http_notify; 
    319                 *pointer += 7; 
    320                 return ret_ok; 
    321         } else if (cmp_str (line, "POLL ")) { 
    322                 hdr->method = http_poll; 
    323                 *pointer += 5; 
    324                 return ret_ok; 
    325         } else if (cmp_str (line, "PROPFIND ")) { 
    326                 hdr->method = http_propfind; 
    327                 *pointer += 9; 
    328                 return ret_ok; 
    329         } else if (cmp_str (line, "PROPPATCH ")) { 
    330                 hdr->method = http_proppatch; 
    331                 *pointer += 10; 
    332                 return ret_ok; 
    333         } else if (cmp_str (line, "SEARCH ")) { 
    334                 hdr->method = http_search; 
    335                 *pointer += 7; 
    336                 return ret_ok; 
    337         } else if (cmp_str (line, "SUBSCRIBE ")) { 
    338                 hdr->method = http_subscribe; 
    339                 *pointer += 10; 
    340                 return ret_ok; 
    341         } else if (cmp_str (line, "UNLOCK ")) { 
    342                 hdr->method = http_unlock; 
    343                 *pointer += 7; 
    344                 return ret_ok; 
    345         } else if (cmp_str (line, "UNSUBSCRIBE ")) { 
    346                 hdr->method = http_unsubscribe; 
    347                 *pointer += 12; 
    348                 return ret_ok; 
     264        char chr = *line; 
     265 
     266#define detect_method(l,str,mthd)                         \ 
     267        if (cmp_str (line+1, ((const char *)str" ")+1)) { \ 
     268                hdr->method = http_ ## mthd;              \ 
     269                *pointer += sizeof(str);                  \ 
     270                return ret_ok;                            \ 
     271        }                                                 \ 
     272 
     273        /* Check the first letter of the method name, if it matches it 
     274         * can continue with the rest. 
     275         */ 
     276        switch (chr) { 
     277        case 'G': 
     278                detect_method (line, "GET", get) 
     279                break; 
     280        case 'P': 
     281                detect_method (line, "POST", post) 
     282                else 
     283                detect_method (line, "PUT", put) 
     284                else 
     285                detect_method (line, "POLL", poll) 
     286                else 
     287                detect_method (line, "PROPFIND", propfind) 
     288                else 
     289                detect_method (line, "PROPPATCH", proppatch) 
     290                break; 
     291        case 'H': 
     292                detect_method (line, "HEAD", head) 
     293                break; 
     294        case 'O': 
     295                detect_method (line, "OPTIONS", options) 
     296                break; 
     297        case 'D': 
     298                detect_method (line, "DELETE", delete) 
     299                break; 
     300        case 'T': 
     301                detect_method (line, "TRACE", trace) 
     302                break; 
     303        case 'C': 
     304                detect_method (line, "CONNECT", connect) 
     305                else 
     306                detect_method (line, "COPY", copy) 
     307                break; 
     308        case 'L': 
     309                detect_method (line, "LOCK", lock) 
     310                break; 
     311        case 'M': 
     312                detect_method (line, "MKCOL", mkcol) 
     313                else  
     314                detect_method (line, "MOVE", move) 
     315                break; 
     316        case 'N': 
     317                detect_method (line, "NOTIFY", notify) 
     318                break; 
     319        case 'S': 
     320                detect_method (line, "SEARCH", search) 
     321                else 
     322                detect_method (line, "SUBSCRIBE", subscribe) 
     323                break; 
     324        case 'U': 
     325                detect_method (line, "UNLOCK", unlock) 
     326                else 
     327                detect_method (line, "UNSUBSCRIBE", unsubscribe) 
     328                break; 
    349329        } 
    350330 
    …… 
    401381        switch (end[-1]) { 
    402382        case '1': 
    403                 if (unlikely(strncmp (end-8, "HTTP/1.1", 8) != 0)) 
     383                if (unlikely (! cmp_str (end-8, "HTTP/1.1"))) 
    404384                        goto error; 
    405385                hdr->version = http_version_11;  
    406386                break; 
    407387        case '0': 
    408                 if (unlikely(strncmp (end-8, "HTTP/1.0", 8) != 0)) 
     388                if (unlikely (! cmp_str (end-8, "HTTP/1.0"))) 
    409389                        goto error; 
    410390                hdr->version = http_version_10;  
    411391                break; 
    412392        case '9': 
    413                 if (unlikely(strncmp (end-8, "HTTP/0.9", 8) != 0)) 
     393                if (unlikely (! cmp_str (end-8, "HTTP/0.9"))) 
    414394                        goto error; 
    415395                hdr->version = http_version_09;  

  • cherokee/trunk/cherokee/logger_ncsa.c

    r347 r405  
    246246        char               ipaddr[CHE_INET_ADDRSTRLEN]; 
    247247        static long       *this_timezone = NULL; 
    248         cherokee_buffer_t *combined_info = NULL; 
     248        cherokee_buffer_t combined_info = CHEROKEE_BUF_INIT; 
    249249        cherokee_buffer_t *request; 
    250250 
    …… 
    283283         */ 
    284284        if (logger->combined) { 
    285                 char *ref; 
    286                 char *usr; 
    287                 CHEROKEE_NEW2(referer, useragent, buffer); 
    288  
    289                 cherokee_header_copy_known (&cnt->header, header_referer, referer); 
    290                 cherokee_header_copy_known (&cnt->header, header_user_agent, useragent); 
    291  
    292                 ref = (referer->buf) ? referer->buf : "-"; 
    293                 usr = (useragent->buf) ? useragent->buf : ""; 
    294  
    295                 cherokee_buffer_new (&combined_info); 
    296                 cherokee_buffer_add_va (combined_info, " \"%s\" \"%s\"", ref, usr); 
    297  
    298                 cherokee_buffer_free (referer); 
    299                 cherokee_buffer_free (useragent); 
     285                cherokee_buffer_t referer   = CHEROKEE_BUF_INIT; 
     286                cherokee_buffer_t useragent = CHEROKEE_BUF_INIT; 
     287 
     288                cherokee_header_copy_known (&cnt->header, header_referer, &referer); 
     289                cherokee_header_copy_known (&cnt->header, header_user_agent, &useragent); 
     290 
     291                cherokee_buffer_ensure_size (&combined_info, 8 + referer.len + referer.len); 
     292 
     293                if (referer.len > 0) { 
     294                        cherokee_buffer_add_str (&combined_info, " \""); 
     295                        cherokee_buffer_add_buffer (&combined_info, &referer); 
     296                        cherokee_buffer_add_str (&combined_info, "\" \""); 
     297                } else { 
     298                        cherokee_buffer_add_str (&combined_info, "\"-\" \""); 
     299                } 
     300                 
     301                if (useragent.len > 0) { 
     302                        cherokee_buffer_add_buffer (&combined_info, &useragent); 
     303                }  
     304                cherokee_buffer_add_str (&combined_info, "\""); 
     305 
     306                cherokee_buffer_mrproper (&referer); 
     307                cherokee_buffer_mrproper (&useragent); 
    300308        } 
    301309 
    …… 
    306314         */ 
    307315        cherokee_buffer_add_va (buf,  
    308                                 "%s - %s [%02d/%s/%d:%02d:%02d:%02d %c%02d%02d] \"%s %s %s\" %d " FMT_OFFSET "%s\n", 
     316                                "%s - %s [%02d/%s/%d:%02d:%02d:%02d %c%02d%02d] \"%s %s %s\" %d " FMT_OFFSET, 
    309317                                ipaddr, 
    310318                                username,  
    …… 
    322330                                version,  
    323331                                cnt->error_code, 
    324                                 (CST_OFFSET) (cnt->range_end - cnt->range_start), 
    325                                 (logger->combined) ? combined_info->buf : ""); 
     332                                (CST_OFFSET) (cnt->range_end - cnt->range_start)); 
     333 
     334        if (logger->combined) { 
     335                cherokee_buffer_add_buffer (buf, &combined_info); 
     336        } 
     337 
     338        cherokee_buffer_add_str (buf, "\n"); 
    326339         
    327340        /* Maybe free some memory.. 
    328341         */ 
    329         if (combined_info != NULL) { 
    330                 cherokee_buffer_free (combined_info); 
    331         } 
    332  
     342        cherokee_buffer_mrproper (&combined_info); 
    333343        return ret_ok; 
    334344 

  • cherokee/trunk/cherokee/util.c

    r399 r405  
    552552cherokee_estimate_va_length (char *fmt, va_list ap) 
    553553{ 
    554         char      *p; 
    555         int        ch; 
    556         cullong_t  ul; 
    557         int        base, lflag, llflag, width; 
    558         char       padc; 
    559         unsigned   len = 0; 
     554        char               *p; 
     555        cuchar_t            ch; 
     556        cullong_t           ul; 
     557        cherokee_boolean_t  lflag; 
     558        cherokee_boolean_t  llflag; 
     559        cuint_t             width; 
     560        char                padc; 
     561        cuint_t             len = 0; 
     562 
     563 
     564#define LEN_NUM(base)       \ 
     565        do {                \ 
     566                ul /= base; \ 
     567                len++;      \ 
     568        } while (ul > 0);   \ 
     569        len++; 
     570 
    560571 
    561572        for (;;) { 
    562                 padc = ' '; 
    563573                width = 0; 
    564                 while ((ch = *(char *)fmt++) != '%') { 
     574                padc  = ' '; 
     575 
     576                while ((ch = *fmt++) != '%') { 
    565577                        if (ch == '\0') 
    566578                                return len+1; 
    567579                        len++; 
    568580                } 
    569                 lflag = llflag = 0; 
     581                lflag = llflag = false; 
    570582 
    571583reswitch:        
    572                 switch (ch = *(char *)fmt++) { 
     584                switch (ch = *fmt++) { 
     585                case 's': 
     586                        p = va_arg(ap, char *); 
     587                        len += strlen (p? p: "(null)"); 
     588                        break; 
     589                case 'd': 
     590                        ul = lflag ? va_arg(ap, culong_t) : va_arg(ap, int); 
     591                        if (ul < 0) { 
     592                                ul = -ul; 
     593                                len++; 
     594                        } 
     595                        LEN_NUM(10); 
     596                        break; 
     597                case 'l': 
     598                        if (lflag == false)  
     599                                lflag = true; 
     600                        else 
     601                                llflag = true; 
     602                        goto reswitch; 
     603                case 'u': 
     604                        if (llflag) { 
     605                                ul = va_arg(ap, cullong_t); 
     606                        } else { 
     607                                ul = lflag ? va_arg(ap, long) : va_arg(ap, int); 
     608                        } 
     609                        LEN_NUM(10); 
     610                        break; 
    573611                case '0': 
    574612                        padc = '0'; 
    …… 
    584622                        len += width; 
    585623                        goto reswitch; 
    586                 case 'l': 
    587                         if (lflag == 0)  
    588                                 lflag = 1; 
    589                         else 
    590                                 llflag = 1; 
    591                         goto reswitch; 
    592624                case 'c': 
    593625                        va_arg(ap, int); 
    594626                        len++; 
    595627                        break; 
    596                 case 's': 
    597                         p = va_arg(ap, char *); 
    598                         len += strlen (p? p: "(null)"); 
    599                         break; 
    600                 case 'd': 
    601                         ul = lflag ? va_arg(ap, culong_t) : va_arg(ap, int); 
    602                         if (ul < 0) { 
    603                                 ul = -ul; 
    604                                 len++; 
    605                         } 
    606                         base = 10; 
    607                         goto number; 
    608628                case 'o': 
    609629                        ul = lflag ? va_arg(ap, culong_t) : va_arg(ap, int); 
    610                         base = 8; 
    611                         goto number; 
    612                 case 'u': 
    613                         if (llflag) { 
    614                                 ul = va_arg(ap, cullong_t); 
    615                         } else { 
    616                                 ul = lflag ? va_arg(ap, long) : va_arg(ap, int); 
    617                         } 
    618                         base = 10; 
    619                         goto number; 
     630                        LEN_NUM(8); 
     631                        break; 
    620632                case 'f': 
    621633                        ul = va_arg(ap, double); /* FIXME: Add float numbers support */ 
    622634                        len += 30;  
    623                         base = 10; 
    624                         goto number;                    
     635                        LEN_NUM(10); 
     636                        break; 
    625637                case 'p': 
    626638                        len += 2;                /* Pointer: "0x" + hex value */ 
    627639                case 'x': 
    628640                        ul = lflag ? va_arg(ap, culong_t) : va_arg(ap, int); 
    629                         base = 16; 
    630 number: 
    631                         do { 
    632                                 ul /= base; 
    633                                 len++; 
    634                         } while (ul > 0); 
    635                         len++; 
     641                        LEN_NUM(16); 
    636642                        break; 
    637                         ; 
    638643                case '%': 
    639644                        len++;