Changeset 793

Show
Ignore:
Timestamp:
07/07/07 16:34:21 (1 year ago)
Author:
adefacc
Message:

ptr. math fixes + fix mispellings

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r792 r793  
     1 
     22007-07-03  A.D.F  <adefacc@tin.it> 
     3 
     4        * cherokee/connection.c 
     5          - cherokee_connection_send_header_and mmaped(): 
     6            - always decrement conn->mmaped_len; 
     7            - avoid ptr. math with pointers to void 
     8              by using a cast to (char *) and then back to (void *). 
     9 
     10        * qa/run-tests.py 
     11          - Corrected mispelled word (Sucess -> Success). 
     12 
    1132007-07-04  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    214 

  • cherokee/trunk/cherokee/connection.c

    r771 r793  
    596596cherokee_connection_send_header_and_mmaped (cherokee_connection_t *conn) 
    597597{ 
    598         size_t  re; 
     598        size_t  re = 0; 
    599599        ret_t   ret; 
    600600        int16_t nvec = 1; 
    …… 
    602602 
    603603        /* 1.- Special case: There is not header to send 
    604          * It is becase it has been sent in a writev() 
     604         * because it has been sent by writev() (see below) 
    605605         */ 
    606606        if (cherokee_buffer_is_empty (&conn->buffer)) { 
    607607                ret = cherokee_socket_write (&conn->socket, conn->mmaped, conn->mmaped_len, &re); 
    608                 switch (ret) { 
    609                 case ret_eof: 
    610                 case ret_eagain: 
    611                         return ret; 
    612  
    613                 case ret_error: 
    614                         conn->keepalive = 0; 
    615                         return ret_error; 
    616  
    617                 default: 
    618                         break; 
    619                 } 
    620                  
     608                if (unlikely (ret != ret_ok) ) { 
     609                        switch (ret) { 
     610                        case ret_eof: 
     611                        case ret_eagain: 
     612                                return ret; 
     613 
     614                        case ret_error: 
     615                                conn->keepalive = 0; 
     616                                return ret; 
     617 
     618                        default: 
     619                                conn->keepalive = 0; 
     620                                RET_UNKNOWN(ret); 
     621                                return ret_error; 
     622                        } 
     623                }                
    621624                cherokee_connection_tx_add (conn, re); 
    622625 
    623                 /* FIXME: conn->mmaped is a ptr. to void 
    624                  * so ptr. math should be avoided. 
    625                  */ 
    626                 conn->mmaped     += re; 
     626                /* NOTE: conn->mmaped is a ptr. to void 
     627                 * so we have to apply ptr. math carefully. 
     628                 */ 
     629                conn->mmaped      = (void *) ( ((char *)conn->mmaped) + re ); 
    627630                conn->mmaped_len -= (off_t) re; 
    628631 
    629                 return (conn->mmaped_len <= 0) ? ret_ok : ret_eagain; 
     632                return (conn->mmaped_len > 0) ? ret_eagain : ret_ok; 
    630633        } 
    631634 
    …… 
    640643        } 
    641644        ret = cherokee_socket_writev (&conn->socket, bufs, nvec, &re); 
    642  
    643         switch (ret) { 
    644         case ret_ok:  
    645                 break; 
    646  
    647         case ret_eof: 
    648         case ret_eagain:  
    649                 return ret; 
    650  
    651         case ret_error: 
    652                 conn->keepalive = 0; 
    653                 return ret_error; 
    654  
    655         default: 
    656                 RET_UNKNOWN(ret); 
    657                 return ret_error; 
    658         } 
    659  
     645        if (unlikely (ret != ret_ok)) { 
     646                switch (ret) { 
     647 
     648                case ret_eof: 
     649                case ret_eagain:  
     650                        return ret; 
     651 
     652                case ret_error: 
     653                        conn->keepalive = 0; 
     654                        return ret_error; 
     655 
     656                default: 
     657                        RET_UNKNOWN(ret); 
     658                        return ret_error; 
     659                } 
     660        } 
    660661        /* Add to the connection traffic counter 
    661662         */ 
    662663        cherokee_connection_tx_add (conn, re); 
    663664 
    664         /* If writev() has sent all data.  
    665          */ 
    666         if (re == (size_t) (conn->buffer.len + conn->mmaped_len)) { 
    667                 cherokee_buffer_clean (&conn->buffer); 
    668                 return ret_ok; 
    669         } 
    670  
    671         /* writev() may not have sent all data. 
    672          */ 
    673         if (re <= (size_t) conn->buffer.len) { 
     665        /* writev() may not have sent all headers data. 
     666         */ 
     667        if (unlikely (re < (size_t) conn->buffer.len)) { 
     668                /* Partial header data sent. 
     669                 */ 
    674670                cherokee_buffer_move_to_begin (&conn->buffer, re); 
    675                 if (conn->mmaped_len > 0) 
    676                         return ret_eagain; 
    677                 return ret_ok; 
    678         } 
    679  
    680         /* writev() has not sent all data: 
    681          * re > conn->buffer.len && conn->mmaped_len > 0; 
     671                return ret_eagain; 
     672        } 
     673 
     674        /* OK, all headers have been sent, 
     675         * subtract from amount sent and clean header buffer. 
    682676         */ 
    683677        re -= (size_t) conn->buffer.len; 
    684  
    685         /* FIXME: conn->mmaped is a ptr. to void 
    686          * so ptr. math should be avoided. 
    687          */ 
    688         conn->mmaped     += re; 
     678        cherokee_buffer_clean (&conn->buffer); 
     679 
     680        /* NOTE: conn->mmaped is a ptr. to void 
     681         * so we have to apply ptr. math carefully. 
     682         */ 
     683        conn->mmaped      = (void *) ( ((char *)conn->mmaped) + re ); 
    689684        conn->mmaped_len -= (off_t) re; 
    690685 
    691         cherokee_buffer_clean (&conn->buffer); 
    692  
    693         return ret_eagain; 
     686        return (conn->mmaped_len > 0) ? ret_eagain : ret_ok; 
    694687} 
    695688 

  • cherokee/trunk/qa/run-tests.py

    r708 r793  
    299299                sys.exit(1) 
    300300            elif not quiet: 
    301                 print "Sucess" 
     301                print "Success" 
    302302                obj.Clean() 
    303303