Changeset 2055

Show
Ignore:
Timestamp:
01/18/2008 10:54:15 AM (6 months ago)
Author:
glen
Message:

- mod_deflate: filesize check is too weak, move to new logstyle. #1512

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/mod_deflate.c

    r2033 r2055  
    262262                if((s->compression_level < 1 || s->compression_level > 9) && 
    263263                                s->compression_level != Z_DEFAULT_COMPRESSION) { 
    264                         log_error_write(srv, __FILE__, __LINE__, "sd",  
    265                                 "compression-level must be between 1 and 9:", s->compression_level); 
     264                        ERROR("compression-level must be between 1 and 9: %i", s->compression_level); 
    266265                        return HANDLER_ERROR; 
    267266                } 
    268267 
    269268                if(s->mem_level < 1 || s->mem_level > 9) { 
    270                         log_error_write(srv, __FILE__, __LINE__, "sd",  
    271                                 "mem-level must be between 1 and 9:", s->mem_level); 
     269                        ERROR("mem-level must be between 1 and 9: %i", s->mem_level); 
    272270                        return HANDLER_ERROR; 
    273271                } 
    274272 
    275273                if(s->window_size < 1 || s->window_size > 15) { 
    276                         log_error_write(srv, __FILE__, __LINE__, "sd",  
    277                                 "window-size must be between 1 and 15:", s->window_size); 
     274                        ERROR("window-size must be between 1 and 15: %i", s->window_size); 
    278275                        return HANDLER_ERROR; 
    279276                } 
     
    320317         
    321318        if(p->conf.debug) { 
    322                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    323                         "output-buffer-size:", p->conf.output_buffer_size); 
    324                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    325                         "compression-level:", p->conf.compression_level); 
    326                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    327                         "mem-level:", p->conf.mem_level); 
    328                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    329                         "window-size:", p->conf.window_size); 
    330                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    331                         "min-compress-size:", p->conf.min_compress_size); 
    332                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    333                         "work-block-size:", p->conf.work_block_size); 
     319                TRACE("output-buffer-size: %i", p->conf.output_buffer_size); 
     320                TRACE("compression-level: %i", p->conf.compression_level); 
     321                TRACE("mem-level: %i", p->conf.mem_level); 
     322                TRACE("window-size: %i", p->conf.window_size); 
     323                TRACE("min-compress-size: %i", p->conf.min_compress_size); 
     324                TRACE("work-block-size: %i", p->conf.work_block_size); 
    334325        } 
    335326        if (Z_OK != (r = deflateInit2(z,  
     
    369360                        buffer_copy_memory(hctx->output, gzip_header, sizeof(gzip_header)); 
    370361                        if(p->conf.debug) { 
    371                                 log_error_write(srv, __FILE__, __LINE__, "sd", 
    372                                                 "gzip_header len=", sizeof(gzip_header)); 
     362                                TRACE("gzip_header len=%i", sizeof(gzip_header)); 
    373363                        } 
    374364                        /* initialize crc32 */ 
     
    404394 
    405395        if(p->conf.debug) { 
    406                 log_error_write(srv, __FILE__, __LINE__, "sdsd", 
    407                                 "compress: in=", in, ", out=", out); 
     396                TRACE("compress: in=%i, out=%i", in, out); 
    408397        } 
    409398        return st_size; 
     
    470459 
    471460        if(p->conf.debug) { 
    472                 log_error_write(srv, __FILE__, __LINE__, "sdsd", 
    473                                 "flush: in=", in, ", out=", out); 
     461                TRACE("flush: in=%i, out=%i", in, out); 
    474462        } 
    475463        if(p->conf.sync_flush) { 
     
    508496                hctx->out->bytes_in += 8; 
    509497                if(p->conf.debug) { 
    510                         log_error_write(srv, __FILE__, __LINE__, "sd", 
    511                                         "gzip_footer len=", 8); 
     498                        TRACE("gzip_footer len=%i", 8); 
    512499                } 
    513500        } 
     
    516503                if(rc == Z_DATA_ERROR) return 0; 
    517504                if(z->msg != NULL) { 
    518                         log_error_write(srv, __FILE__, __LINE__, "sdss", 
    519                                         "deflateEnd error ret=", rc, ", msg=", z->msg); 
     505                        ERROR("deflateEnd error ret=%i, msg='%s'", rc, z->msg); 
    520506                } else { 
    521                         log_error_write(srv, __FILE__, __LINE__, "sd", 
    522                                         "deflateEnd error ret=", rc); 
     507                        ERROR("deflateEnd error ret=%i", rc); 
    523508                } 
    524509                return -1; 
     
    547532         
    548533        if(p->conf.debug) { 
    549                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    550                         "output-buffer-size:", p->conf.output_buffer_size); 
    551                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    552                         "compression-level:", p->conf.compression_level); 
    553                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    554                         "mem-level:", p->conf.mem_level); 
    555                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    556                         "window-size:", p->conf.window_size); 
    557                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    558                         "min-compress-size:", p->conf.min_compress_size); 
    559                 log_error_write(srv, __FILE__, __LINE__, "sd",  
    560                         "work-block-size:", p->conf.work_block_size); 
     534                TRACE("output-buffer-size: %i", p->conf.output_buffer_size); 
     535                TRACE("compression-level: %i", p->conf.compression_level); 
     536                TRACE("mem-level: %i", p->conf.mem_level); 
     537                TRACE("window-size: %i", p->conf.window_size); 
     538                TRACE("min-compress-size: %i", p->conf.min_compress_size); 
     539                TRACE("work-block-size: %i", p->conf.work_block_size); 
    561540        } 
    562541        if (BZ_OK != BZ2_bzCompressInit(bz,  
     
    612591        } while (bz->avail_in > 0); 
    613592        if(p->conf.debug) { 
    614                 log_error_write(srv, __FILE__, __LINE__, "sdsd", 
    615                                 "compress: in=", in, ", out=", out); 
     593                TRACE("compress: in=%i, out=%i", in, out); 
    616594        } 
    617595        return st_size; 
     
    669647        } while (bz->avail_in != 0 || !done); 
    670648        if(p->conf.debug) { 
    671                 log_error_write(srv, __FILE__, __LINE__, "sdsd", 
    672                                 "flush: in=", in, ", out=", out); 
     649                TRACE("flush: in=%i, out=%i", in, out); 
    673650        } 
    674651        if(p->conf.sync_flush) { 
     
    685662 
    686663        UNUSED(p); 
     664        UNUSED(srv); 
    687665        UNUSED(con); 
    688666 
     
    693671        if ((rc = BZ2_bzCompressEnd(bz)) != BZ_OK) { 
    694672                if(rc == BZ_DATA_ERROR) return 0; 
    695                 log_error_write(srv, __FILE__, __LINE__, "sd", 
    696                                 "BZ2_bzCompressEnd error ret=", rc); 
     673                ERROR("BZ2_bzCompressEnd error ret=%i", rc); 
    697674                return -1; 
    698675        } 
     
    781758 
    782759        if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) { 
    783                 ERROR("stat_cache_get_entry(%s) failed: %s",  
     760                ERROR("stat_cache_get_entry('%s') failed: %s", 
    784761                                BUF_STR(c->file.name), strerror(errno)); 
    785762                return -1; 
     
    788765        abs_offset = c->file.start + c->offset; 
    789766         
    790         if (abs_offset > sce->st.st_size) { 
     767        if (c->file.length + c->file.start > sce->st.st_size) { 
    791768                ERROR("file '%s' was shrinked: was %lld, is %lld (%lld, %lld)",  
    792                                 BUF_STR(c->file.name), abs_offset, sce->st.st_size, 
     769                                BUF_STR(c->file.name), c->file.length + c->file.start, sce->st.st_size, 
    793770                                c->file.start, c->offset); 
    794771                 
     
    848825                if (-1 == c->file.fd) {  /* open the file if not already open */ 
    849826                        if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) { 
    850                                 log_error_write(srv, __FILE__, __LINE__, "sbs", "open failed for:", c->file.name, strerror(errno)); 
    851                  
     827                                ERROR("open failed for '%s': %s", BUF_STR(c->file.name), strerror(errno)); 
    852828                                return -1; 
    853829                        } 
     
    860836                        /* close it here, otherwise we'd have to set FD_CLOEXEC */ 
    861837 
    862                         log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed:",  
    863                                         strerror(errno), c->file.name, c->file.fd); 
    864  
     838                        ERROR("mmap failed for '%s' (%i): %s", BUF_STR(c->file.name), c->file.fd, strerror(errno)); 
    865839                        return -1; 
    866840                } 
     
    874848                if (c->file.mmap.length > (64 KByte) &&  
    875849                    0 != madvise(c->file.mmap.start, c->file.mmap.length, MADV_WILLNEED)) { 
    876                         log_error_write(srv, __FILE__, __LINE__, "ssbd", "madvise failed:",  
    877                                         strerror(errno), c->file.name, c->file.fd); 
     850                        ERROR("madvise failed for '%s' (%i): %s", BUF_STR(c->file.name), c->file.fd, strerror(errno)); 
    878851                } 
    879852#endif 
     
    888861 
    889862        if (toSend < 0) { 
    890                 log_error_write(srv, __FILE__, __LINE__, "soooo",  
    891                                 "toSend is negative:", 
    892                                 toSend, 
    893                                 c->file.mmap.length, 
    894                                 abs_offset, 
    895                                 c->file.mmap.offset);  
     863                ERROR("toSend is negative: %u %u %u %u", 
     864                                (unsigned int) toSend, 
     865                                (unsigned int) c->file.mmap.length, 
     866                                (unsigned int) abs_offset, 
     867                                (unsigned int) c->file.mmap.offset); 
    896868                assert(toSend < 0); 
    897869        } 
     
    904876 
    905877        if(p->conf.debug) { 
    906                 log_error_write(srv, __FILE__, __LINE__, "sdsd", 
    907                                 "compress file chunk: offset=", (int)c->offset, 
    908                                 ", toSend=", (int)toSend); 
     878                TRACE("compress file chunk: offset=%i, toSend=%i", (int)c->offset, (int)toSend); 
    909879        } 
    910880        if (mod_deflate_compress(srv, con, hctx, 
    911881                                (unsigned char *)start + (abs_offset - c->file.mmap.offset), toSend) < 0) { 
    912                 log_error_write(srv, __FILE__, __LINE__, "s",  
    913                                 "compress failed."); 
     882                ERROR("compress failed.", 0); 
    914883                return -1; 
    915884        } 
     
    929898 
    930899        if(p->conf.debug && hctx->bytes_in < hctx->out->bytes_in) { 
    931                 TRACE("(debug) compressing uri '%s' increased the sent content-size from %lld to %lld", 
     900                TRACE("compressing uri '%s' increased the sent content-size from %i to %lld", 
    932901                        BUF_STR(con->uri.path_raw), hctx->bytes_in, hctx->out->bytes_in); 
    933902        } 
     
    958927        we_have = chunkqueue_length(hctx->in); 
    959928        if (p->conf.debug) { 
    960                 log_error_write(srv, __FILE__, __LINE__, "sd", 
    961                                 "compress: in_queue len=", we_have); 
     929                TRACE("compress: in_queue len=%i", we_have); 
    962930        } 
    963931        /* calculate max bytes to compress for this call. */ 
     
    985953 
    986954                        if (mod_deflate_compress(srv, con, hctx, (unsigned char *)(c->mem->ptr + c->offset), we_want) < 0) { 
    987                                 log_error_write(srv, __FILE__, __LINE__, "s",  
    988                                                 "compress failed."); 
     955                                ERROR("compress failed.", 0); 
    989956                                return HANDLER_ERROR; 
    990957                        } 
     
    1000967                         
    1001968                        if ((we_want = mod_deflate_file_chunk(srv, con, hctx, c, we_want)) < 0) { 
    1002                                 log_error_write(srv, __FILE__, __LINE__, "s",  
    1003                                                 "compress file chunk failed."); 
     969                                ERROR("compress file chunk failed.", 0); 
    1004970                                return HANDLER_ERROR; 
    1005971                        } 
     
    10351001 
    10361002        if (p->conf.debug) { 
    1037                 log_error_write(srv, __FILE__, __LINE__, "sd", 
    1038                                 "compressed bytes:", out); 
     1003                TRACE("compressed bytes: %i", out); 
    10391004        } 
    10401005 
     
    10541019 
    10551020        if (rc < 0) { 
    1056                 log_error_write(srv, __FILE__, __LINE__, "s", "flush error"); 
     1021                ERROR("flush error", 0); 
    10571022        } 
    10581023         
     
    10601025                hctx->out->is_closed = 1; 
    10611026                if(p->conf.debug) { 
    1062                         log_error_write(srv, __FILE__, __LINE__, "sbsb", 
    1063                                         "finished uri:", con->uri.path_raw, ", query:", con->uri.query); 
     1027                        TRACE("finished uri: '%s', query: '%s'", BUF_STR(con->uri.path_raw), BUF_STR(con->uri.query)); 
    10641028                } 
    10651029        } else { 
     
    11611125        if(!p->conf.enabled) { 
    11621126                if(p->conf.debug) { 
    1163                         log_error_write(srv, __FILE__, __LINE__, "s", "compression disabled."); 
     1127                        TRACE("compression disabled.", 0); 
    11641128                } 
    11651129                return HANDLER_GO_ON; 
     
    12011165                 */ 
    12021166                /* most of buggy clients are Yahoo Slurp;) */ 
    1203                 if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ss", 
    1204                                 "Buggy HTTP 1.0 client sending Accept Encoding: gzip, deflate",  
     1167                if (p->conf.debug) TRACE("Buggy HTTP 1.0 client sending 'Accept Encoding: gzip, deflate': %i", 
    12051168                                (char *) inet_ntop_cache_get_ip(srv, &(con->dst_addr))); 
    12061169                return HANDLER_GO_ON; 
     
    12111174        fl = filter_chain_get_filter(con->send_filters, p->id); 
    12121175        if (!fl) { 
    1213                 if(p->conf.debug) TRACE("%s", "add deflate filter to filter chain"); 
     1176                if(p->conf.debug) TRACE("add deflate filter to filter chain", 0); 
    12141177                fl = filter_chain_create_filter(con->send_filters, p->id); 
    12151178        } 
     
    12341197        if(file_len > 0 && p->conf.min_compress_size > 0 && file_len < p->conf.min_compress_size) { 
    12351198                if(p->conf.debug) { 
    1236                         log_error_write(srv, __FILE__, __LINE__, "sd", 
    1237                                         "Content-Length smaller then min_compress_size: file_len=", file_len); 
     1199                        TRACE("Content-Length smaller then min_compress_size: file_len=%i", file_len); 
    12381200                } 
    12391201                filter_chain_remove_filter(con->send_filters, fl); 
     
    12451207                int found = 0; 
    12461208                if(p->conf.debug) { 
    1247                         log_error_write(srv, __FILE__, __LINE__, "sb", 
    1248                                         "Content-Type:", ds->value); 
     1209                        TRACE("Content-Type: %s", BUF_STR(ds->value)); 
    12491210                } 
    12501211                for (m = 0; m < p->conf.mimetypes->used; m++) { 
     
    12521213 
    12531214                        if(p->conf.debug) { 
    1254                                 log_error_write(srv, __FILE__, __LINE__, "sb", 
    1255                                                 "mime-type:", mimetype->value); 
     1215                                TRACE("mime-type:", BUF_STR(mimetype->value)); 
    12561216                        } 
    12571217                        if (strncmp(mimetype->value->ptr, ds->value->ptr, mimetype->value->used-1) == 0) { 
     
    12631223                if(!found && p->conf.mimetypes->used > 0) { 
    12641224                        if(p->conf.debug) { 
    1265                                 log_error_write(srv, __FILE__, __LINE__, "sb", 
    1266                                                 "No compression for mimetype:", ds->value); 
     1225                                TRACE("No compression for mimetype: %s", BUF_STR(ds->value)); 
    12671226                        } 
    12681227                        filter_chain_remove_filter(con->send_filters, fl); 
     
    12851244                        buffer_append_string(ds->value, ",Accept-Encoding"); 
    12861245                        if (p->conf.debug) { 
    1287                                 log_error_write(srv, __FILE__, __LINE__, "sb", 
    1288                                                 "appending ,Accept-Encoding for ", con->uri.path); 
     1246                                TRACE("appending ,Accept-Encoding for '%s'", BUF_STR(con->uri.path)); 
    12891247                        } 
    12901248                } 
    12911249        } else { 
    12921250                if (p->conf.debug) { 
    1293                         log_error_write(srv, __FILE__, __LINE__, "sb", 
    1294                                         "add Vary: Accept-Encoding for ", con->uri.path); 
     1251                        TRACE("add Vary: Accept-Encoding for '%s'", BUF_STR(con->uri.path)); 
    12951252                } 
    12961253                response_header_insert(srv, con, CONST_STR_LEN("Vary"), 
     
    13711328                end = 1; 
    13721329                if(p->conf.debug) { 
    1373                         log_error_write(srv, __FILE__, __LINE__, "sd", 
    1374                                         "Compress all content and use Content-Length header: uncompress len=", file_len); 
     1330                        TRACE("Compress all content and use Content-Length header: uncompress len=%i", file_len); 
    13751331                } 
    13761332        } 
    13771333 
    13781334        if (p->conf.debug)  
    1379                 log_error_write(srv, __FILE__, __LINE__, "sdsb", "end =", end, "for uri", con->uri.path); 
     1335                TRACE("end = %i for uri '%s'", end, BUF_STR(con->uri.path)); 
    13801336 
    13811337        rc = deflate_compress_response(srv, con, hctx, end); 
     
    14191375 
    14201376        if(p->conf.debug && hctx->stream_open) { 
    1421                 log_error_write(srv, __FILE__, __LINE__, "sbsb", 
    1422                                 "stream open at cleanup. uri=", con->uri.path_raw, ", query=", con->uri.query); 
     1377                TRACE("stream open at cleanup. uri='%s', query='%s'", BUF_STR(con->uri.path_raw), BUF_STR(con->uri.query)); 
    14231378        } 
    14241379