| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // Author: kspoelstra@we-amp.com (Kees Spoelstra) |
| |
| #include "ngx_gzip_setter.h" |
| |
| #include <ngx_conf_file.h> |
| |
| namespace net_instaweb { |
| |
| NgxGZipSetter g_gzip_setter; |
| |
| extern "C" { |
| // These functions replace the setters for: |
| // gzip |
| // gzip_types |
| // gzip_http_version |
| // gzip_vary |
| // |
| // If these functions are called it means there is an explicit gzip |
| // configuration. The gzip configuration set by pagespeed is then rolled |
| // back and pagespeed will stop enabling gzip automatically. |
| char* ngx_gzip_redirect_conf_set_flag_slot( |
| ngx_conf_t* cf, ngx_command_t* cmd, void* conf) { |
| if (g_gzip_setter.enabled()) { |
| g_gzip_setter.RollBackAndDisable(cf); |
| } |
| char* ret = ngx_conf_set_flag_slot(cf, cmd, conf); |
| return ret; |
| } |
| |
| char* ngx_gzip_redirect_http_types_slot( |
| ngx_conf_t* cf, ngx_command_t* cmd, void* conf) { |
| if (g_gzip_setter.enabled()) { |
| g_gzip_setter.RollBackAndDisable(cf); |
| } |
| char* ret = ngx_http_types_slot(cf, cmd, conf); |
| return ret; |
| } |
| |
| char* ngx_gzip_redirect_conf_set_enum_slot( |
| ngx_conf_t* cf, ngx_command_t* cmd, void* conf) { |
| if (g_gzip_setter.enabled()) { |
| g_gzip_setter.RollBackAndDisable(cf); |
| } |
| char* ret = ngx_conf_set_enum_slot(cf, cmd, conf); |
| return ret; |
| } |
| char* ngx_gzip_redirect_conf_set_bitmask_slot( |
| ngx_conf_t* cf, ngx_command_t* cmd, void* conf) { |
| if (g_gzip_setter.enabled()) { |
| g_gzip_setter.RollBackAndDisable(cf); |
| } |
| char* ret = ngx_conf_set_bitmask_slot(cf, cmd, conf); |
| return ret; |
| } |
| } |
| |
| NgxGZipSetter::NgxGZipSetter() : enabled_(0) { } |
| NgxGZipSetter::~NgxGZipSetter() { } |
| |
| // Helper functions to determine signature. |
| bool HasLocalConfig(ngx_command_t* command) { |
| return (!(command->type & (NGX_DIRECT_CONF|NGX_MAIN_CONF)) && |
| command->conf == NGX_HTTP_LOC_CONF_OFFSET); |
| } |
| bool IsNgxFlagCommand(ngx_command_t* command) { |
| return (command->set == ngx_conf_set_flag_slot && |
| HasLocalConfig(command)); |
| } |
| bool IsNgxHttpTypesCommand(ngx_command_t* command) { |
| return (command->set == ngx_http_types_slot && |
| HasLocalConfig(command)); |
| } |
| bool IsNgxEnumCommand(ngx_command_t* command) { |
| return (command->set == ngx_conf_set_enum_slot && |
| HasLocalConfig(command)); |
| } |
| bool IsNgxBitmaskCommand(ngx_command_t* command) { |
| return (command->set == ngx_conf_set_bitmask_slot && |
| HasLocalConfig(command)); |
| } |
| |
| // Initialize the NgxGzipSetter. |
| // Find the gzip, gzip_vary, gzip_http_version and gzip_types commands in the |
| // gzip module. Enable if the signature of the zip command matches with what we |
| // trust. Also sets up redirects for the configurations. These redirect handle |
| // a rollback if expicit configuration is found. |
| // If commands are not found the method will inform the user by logging. |
| void NgxGZipSetter::Init(ngx_conf_t* cf) { |
| #if (NGX_HTTP_GZIP) |
| bool gzip_signature_mismatch = false; |
| bool other_signature_mismatch = false; |
| for (int m = 0; ngx_modules[m] != NULL; m++) { |
| if (ngx_modules[m]->commands != NULL) { |
| for (int c = 0; ngx_modules[m]->commands[c].name.len; c++) { |
| ngx_command_t* current_command =& ngx_modules[m]->commands[c]; |
| |
| // We look for the gzip command, and the exact signature we trust |
| // this means configured as an config location offset |
| // and a ngx_flag_t setter. |
| // Also see: |
| // ngx_conf_handler in ngx_conf_file.c |
| // ngx_http_gzip_filter_commands in ngx_http_gzip_filter.c |
| if (gzip_command_.command_ == NULL && |
| STR_EQ_LITERAL(current_command->name, "gzip")) { |
| if (IsNgxFlagCommand(current_command)) { |
| current_command->set = ngx_gzip_redirect_conf_set_flag_slot; |
| gzip_command_.command_ = current_command; |
| gzip_command_.module_ = ngx_modules[m]; |
| enabled_ = 1; |
| } else { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, |
| "pagespeed: cannot set gzip, signature mismatch"); |
| gzip_signature_mismatch = true; |
| } |
| } |
| |
| if (!gzip_http_version_command_.command_ && |
| STR_EQ_LITERAL(current_command->name, "gzip_http_version")) { |
| if (IsNgxEnumCommand(current_command)) { |
| current_command->set = ngx_gzip_redirect_conf_set_enum_slot; |
| gzip_http_version_command_.command_ = current_command; |
| gzip_http_version_command_.module_ = ngx_modules[m]; |
| } else { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, |
| "pagespeed: cannot set gzip_http_version, signature mismatch"); |
| other_signature_mismatch = true; |
| } |
| } |
| |
| if (!gzip_proxied_command_.command_ && |
| STR_EQ_LITERAL(current_command->name, "gzip_proxied")) { |
| if (IsNgxBitmaskCommand(current_command)) { |
| current_command->set = ngx_gzip_redirect_conf_set_bitmask_slot; |
| gzip_proxied_command_.command_ = current_command; |
| gzip_proxied_command_.module_ = ngx_modules[m]; |
| } else { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, |
| "pagespeed: cannot set gzip_proxied, signature mismatch"); |
| other_signature_mismatch = true; |
| } |
| } |
| |
| if (!gzip_http_types_command_.command_ && |
| STR_EQ_LITERAL(current_command->name, "gzip_types")) { |
| if (IsNgxHttpTypesCommand(current_command)) { |
| current_command->set = ngx_gzip_redirect_http_types_slot; |
| gzip_http_types_command_.command_ = current_command; |
| gzip_http_types_command_.module_ = ngx_modules[m]; |
| } else { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, |
| "pagespeed: cannot set gzip_types, signature mismatch"); |
| other_signature_mismatch = true; |
| } |
| } |
| |
| if (!gzip_vary_command_.command_ && |
| STR_EQ_LITERAL(current_command->name, "gzip_vary")) { |
| if (IsNgxFlagCommand(current_command)) { |
| current_command->set = ngx_gzip_redirect_conf_set_flag_slot; |
| gzip_vary_command_.command_ = current_command; |
| gzip_vary_command_.module_ = ngx_modules[m]; |
| } else { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, |
| "pagespeed: cannot set gzip_vary, signature mismatch"); |
| other_signature_mismatch = true; |
| } |
| } |
| } |
| } |
| } |
| if (gzip_signature_mismatch) { |
| return; // Already logged error. |
| } else if (!enabled_) { |
| // Looked through all the available commands and didn't find the "gzip" one. |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: cannot set gzip, command not found"); |
| return; |
| } else if (other_signature_mismatch) { |
| return; // Already logged error. |
| } else if (!gzip_vary_command_.command_) { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: missing gzip_vary"); |
| return; |
| } else if (!gzip_http_types_command_.command_) { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: missing gzip_types"); |
| return; |
| } else if (!gzip_http_version_command_.command_) { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: missing gzip_http_version"); |
| return; |
| } else if (!gzip_proxied_command_.command_) { |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: missing gzip_proxied"); |
| return; |
| } else { |
| return; // Success. |
| } |
| #else |
| ngx_conf_log_error( |
| NGX_LOG_WARN, cf, 0, "pagespeed: gzip not compiled into nginx"); |
| return; |
| #endif |
| } |
| |
| void* ngx_command_ctx::GetConfPtr(ngx_conf_t* cf) { |
| return GetModuleConfPtr(cf) + command_->offset; |
| } |
| |
| char* ngx_command_ctx::GetModuleConfPtr(ngx_conf_t* cf) { |
| return reinterpret_cast<char*>( |
| ngx_http_conf_get_module_loc_conf(cf, (*(module_)))); |
| } |
| |
| void NgxGZipSetter::SetNgxConfFlag(ngx_conf_t* cf, |
| ngx_command_ctx* command_ctx, |
| ngx_flag_t value) { |
| ngx_flag_t* flag = reinterpret_cast<ngx_flag_t*>(command_ctx->GetConfPtr(cf)); |
| *flag = value; |
| // Save the flag position for possible rollback. |
| ngx_flags_set_.push_back(flag); |
| } |
| |
| void NgxGZipSetter::SetNgxConfEnum(ngx_conf_t* cf, |
| ngx_command_ctx* command_ctx, |
| ngx_uint_t value) { |
| ngx_uint_t* enum_to_set = |
| reinterpret_cast<ngx_uint_t*>(command_ctx->GetConfPtr(cf)); |
| *enum_to_set = value; |
| ngx_uint_set_.push_back(enum_to_set); |
| } |
| |
| void NgxGZipSetter::SetNgxConfBitmask(ngx_conf_t* cf, |
| ngx_command_ctx* command_ctx, |
| ngx_uint_t value) { |
| ngx_uint_t* enum_to_set = |
| reinterpret_cast<ngx_uint_t*>(command_ctx->GetConfPtr(cf)); |
| *enum_to_set = value; |
| ngx_uint_set_.push_back(enum_to_set); |
| } |
| |
| // These are the content types we want to compress. |
| ngx_str_t gzip_http_types[] = { |
| ngx_string("application/ecmascript"), |
| ngx_string("application/javascript"), |
| ngx_string("application/json"), |
| ngx_string("application/pdf"), |
| ngx_string("application/postscript"), |
| ngx_string("application/x-javascript"), |
| ngx_string("image/svg+xml"), |
| ngx_string("text/css"), |
| ngx_string("text/csv"), |
| // ngx_string("text/html"), // This is the default implied value. |
| ngx_string("text/javascript"), |
| ngx_string("text/plain"), |
| ngx_string("text/xml"), |
| ngx_null_string // Indicates end of array. |
| }; |
| |
| gzs_enable_result NgxGZipSetter::SetGZipForLocation(ngx_conf_t* cf, |
| bool value) { |
| if (!enabled_) { |
| return kEnableGZipNotEnabled; |
| } |
| if (gzip_command_.command_) { |
| SetNgxConfFlag(cf, &gzip_command_, value); |
| } |
| return kEnableGZipOk; |
| } |
| |
| void NgxGZipSetter::EnableGZipForLocation(ngx_conf_t* cf) { |
| if (!enabled_) { |
| return; |
| } |
| |
| // When we get called twice for the same location{}, we ignore the second call |
| // to prevent adding duplicate gzip http types and so on. |
| ngx_flag_t* flag = |
| reinterpret_cast<ngx_flag_t*>(gzip_command_.GetConfPtr(cf)); |
| if (*flag == 1) { |
| return; |
| } |
| SetGZipForLocation(cf, true); |
| if (gzip_vary_command_.command_) { |
| SetNgxConfFlag(cf, &gzip_vary_command_, 1); |
| } |
| if (gzip_http_version_command_.command_) { |
| SetNgxConfEnum(cf, &gzip_http_version_command_, NGX_HTTP_VERSION_10); |
| } |
| if (gzip_proxied_command_.command_) { |
| SetNgxConfBitmask( |
| cf, &gzip_http_version_command_, NGX_HTTP_GZIP_PROXIED_ANY); |
| } |
| |
| // This is actually the most prone to future API changes, because gzip_types |
| // is not a simple type like ngx_flag_t. The signature check should be enough |
| // to prevent problems. |
| AddGZipHTTPTypes(cf); |
| return; |
| } |
| |
| void NgxGZipSetter::AddGZipHTTPTypes(ngx_conf_t* cf) { |
| if (gzip_http_types_command_.command_) { |
| // Following should not happen, but if it does return gracefully. |
| if (cf->args->nalloc < 2) { |
| ngx_conf_log_error(NGX_LOG_WARN, cf, 0, |
| "pagespeed: unexpected small cf->args in gzip_types"); |
| return; |
| } |
| |
| ngx_command_t* command = gzip_http_types_command_.command_; |
| char* gzip_conf = reinterpret_cast<char* >( |
| gzip_http_types_command_.GetModuleConfPtr(cf)); |
| |
| // Backup the old settings. |
| ngx_str_t old_elt0 = reinterpret_cast<ngx_str_t*>(cf->args->elts)[0]; |
| ngx_str_t old_elt1 = reinterpret_cast<ngx_str_t*>(cf->args->elts)[1]; |
| ngx_uint_t old_nelts = cf->args->nelts; |
| |
| // Setup first arg. |
| ngx_str_t gzip_types_string = ngx_string("gzip_types"); |
| reinterpret_cast<ngx_str_t*>(cf->args->elts)[0] = gzip_types_string; |
| cf->args->nelts = 2; |
| |
| ngx_str_t* http_types = gzip_http_types; |
| while (http_types->data) { |
| ngx_str_t d; |
| // We allocate the http type on the configuration pool and actually |
| // leak this if we rollback. This does not seem to be a big problem, |
| // because nginx also allocates tokens in ngx_conf_file.c and does not |
| // free them. This way they can be used safely by configurations. |
| // We must use a copy of gzip_http_types array here because nginx will |
| // manipulate the values. |
| // TODO(kspoelstra): better would be to allocate once on init and not |
| // every time we enable gzip. This needs further investigation, sharing |
| // tokens might be problematic. |
| // For now I think it is not a large problem. This might add up in case |
| // of a large multi server/location config with a lot of "pagespeed on" |
| // directives. |
| // Estimates are 300-400KB for 1000 times "pagespeed on". |
| d.data = reinterpret_cast<u_char*>( |
| ngx_pnalloc(cf->pool, http_types->len + 1)); |
| snprintf(reinterpret_cast<char*>(d.data), http_types->len + 1, "%s", |
| reinterpret_cast<const char*>(http_types->data)); |
| d.len = http_types->len; |
| reinterpret_cast<ngx_str_t*>(cf->args->elts)[1] = d; |
| // Call the original setter. |
| ngx_http_types_slot(cf, command, gzip_conf); |
| http_types++; |
| } |
| |
| // Restore args. |
| cf->args->nelts = old_nelts; |
| reinterpret_cast<ngx_str_t*>(cf->args->elts)[1] = old_elt1; |
| reinterpret_cast<ngx_str_t*>(cf->args->elts)[0] = old_elt0; |
| |
| // Backup configuration location for rollback. |
| ngx_httptypes_set_.push_back(gzip_conf + command->offset); |
| } |
| } |
| |
| void NgxGZipSetter::RollBackAndDisable(ngx_conf_t* cf) { |
| ngx_conf_log_error(NGX_LOG_INFO, cf, 0, |
| "pagespeed: rollback gzip, explicit configuration"); |
| for (std::vector<ngx_flag_t*>::iterator i = ngx_flags_set_.begin(); |
| i != ngx_flags_set_.end(); ++i) { |
| *(*i)=NGX_CONF_UNSET; |
| } |
| for (std::vector<ngx_uint_t*>::iterator i = ngx_uint_set_.begin(); |
| i != ngx_uint_set_.end(); ++i) { |
| *(*i)=NGX_CONF_UNSET_UINT; |
| } |
| for (std::vector<void*>::iterator i = ngx_httptypes_set_.begin(); |
| i != ngx_httptypes_set_.end(); ++i) { |
| ngx_array_t** type_array = reinterpret_cast<ngx_array_t**>(*i); |
| ngx_array_destroy(*type_array); |
| *type_array = NULL; |
| } |
| enabled_ = 0; |
| } |
| |
| } // namespace net_instaweb |
