This is an automated email from the git hooks/post-receive script. sebastic pushed a commit to branch master in repository mapcache.
commit 6ea581b0abf53f14d0d124693aa845fcf8316f0c Author: Bas Couwenberg <[email protected]> Date: Thu Feb 25 20:56:45 2016 +0100 Imported Upstream version 1.4.1 --- CMakeLists.txt | 17 +++- apache/mod_mapcache.c | 252 ++++++++++++++++++++++++++++++++----------------- cgi/mapcache.c | 14 ++- cmake/FindAPACHE.cmake | 2 +- include/mapcache.h | 96 +++++++++---------- include/util.h | 8 +- lib/cache_bdb.c | 51 +++++----- lib/cache_disk.c | 69 +++----------- lib/cache_fallback.c | 8 +- lib/cache_memcache.c | 15 +-- lib/cache_multitier.c | 2 +- lib/cache_rest.c | 131 +++++++++++++------------ lib/cache_riak.c | 20 +++- lib/cache_sqlite.c | 6 +- lib/cache_tiff.c | 29 +----- lib/connection_pool.c | 9 +- lib/core.c | 28 +++--- lib/dimension.c | 49 ++++++---- lib/ezxml.c | 2 +- lib/http.c | 4 +- lib/image.c | 8 +- lib/imageio_png.c | 18 ++-- lib/lock.c | 25 +++-- lib/service_demo.c | 23 ++--- lib/service_wms.c | 18 ++-- lib/service_wmts.c | 9 +- lib/strptime.c | 1 - lib/tileset.c | 42 +++++---- lib/util.c | 69 ++++++++++++-- release.sh | 54 +++++++++++ util/mapcache_seed.c | 161 ++++++++++++++++++------------- 31 files changed, 730 insertions(+), 510 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 218f87a..ea1e62a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,6 @@ include(CheckFunctionExists) include(CheckIncludeFile) include(CheckCSourceCompiles) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug") add_definitions(-DDEBUG) endif () @@ -14,7 +13,7 @@ endif () set (MAPCACHE_VERSION_MAJOR 1) set (MAPCACHE_VERSION_MINOR 4) -set (MAPCACHE_VERSION_REVISION 0) +set (MAPCACHE_VERSION_REVISION 1) if(NOT DEFINED CMAKE_INSTALL_LIBDIR) @@ -58,7 +57,7 @@ endmacro() check_function_exists("strncasecmp" HAVE_STRNCASECMP) check_function_exists("symlink" HAVE_SYMLINK) - +check_function_exists ("timegm" HAVE_TIMEGM) set(CMAKE_SKIP_BUILD_RPATH FALSE) if(APPLE) @@ -74,6 +73,15 @@ set_target_properties(mapcache PROPERTIES SOVERSION 1 ) +# Add compiler flags for warnings +if(CMAKE_COMPILER_IS_GNUCC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror=declaration-after-statement") +endif() + +if(CMAKE_C_COMPILER_ID MATCHES "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror=declaration-after-statement -std=c89 -Wno-comment") +endif() + #options suported by the cmake builder option(WITH_PIXMAN "Use pixman for SSE optimized image manipulations" ON) option(WITH_SQLITE "Use sqlite as a cache backend" ON) @@ -89,7 +97,7 @@ option(WITH_RIAK "Use Riak as a cache backend" OFF) find_package(PNG) if(PNG_FOUND) include_directories(${PNG_INCLUDE_DIR}) - target_link_libraries(mapcache ${PNG_LIBRARY}) + target_link_libraries(mapcache ${PNG_LIBRARIES}) else(PNG_FOUND) report_mandatory_not_found(PNG) endif(PNG_FOUND) @@ -160,6 +168,7 @@ if(WITH_PCRE) include_directories(${PCRE_INCLUDE_DIR}) target_link_libraries(mapcache ${PCRE_LIBRARY}) set (USE_PCRE 1) + add_definitions(-DPCRE_STATIC) else(PCRE_FOUND) report_optional_not_found(PCRE) endif(PCRE_FOUND) diff --git a/apache/mod_mapcache.c b/apache/mod_mapcache.c index 61dc994..832bad2 100644 --- a/apache/mod_mapcache.c +++ b/apache/mod_mapcache.c @@ -73,6 +73,19 @@ struct mapcache_context_apache_request { request_rec *request; }; +typedef struct mapcache_alias_entry mapcache_alias_entry; + +struct mapcache_alias_entry { + char *endpoint; + char *configfile; + mapcache_cfg *cfg; + mapcache_connection_pool *cp; +}; + +struct mapcache_server_cfg { + apr_array_header_t *aliases; /**< list of mapcache configurations aliased to a server uri */ +}; + void apache_context_server_log(mapcache_context *c, mapcache_log_level level, char *message, ...) { mapcache_context_apache_server *ctx = (mapcache_context_apache_server*)c; @@ -183,21 +196,42 @@ static mapcache_context_apache_request* apache_request_context_create(request_re { mapcache_context_apache_request *ctx = apr_pcalloc(r->pool, sizeof(mapcache_context_apache_request)); mapcache_server_cfg *cfg = NULL; - mapcache_cfg *config = NULL; + const char *mapcache_alias; + mapcache_alias_entry *alias_entry; + int i; + mapcache_context *mctx = (mapcache_context*)ctx; - ctx->ctx.ctx.pool = r->pool; + mctx->pool = r->pool; #ifdef APR_HAS_THREADS - ctx->ctx.ctx.threadlock = thread_mutex; + mctx->threadlock = thread_mutex; #endif /* lookup the configuration object given the configuration file name */ cfg = ap_get_module_config(r->server->module_config, &mapcache_module); - config = apr_hash_get(cfg->aliases,(void*)r->filename,APR_HASH_KEY_STRING); - ctx->ctx.ctx.config = config; - ctx->request = r; - ctx->ctx.ctx.connection_pool = cfg->cp; - init_apache_request_context(ctx); - return ctx; + if(!cfg || !cfg->aliases) { + return NULL; + } + + mapcache_alias = apr_table_get(r->notes,"mapcache_alias_entry"); + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "using mapcache config %s", mapcache_config_file); + if(!mapcache_alias) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mapcache module bug? no mapcache_alias_entry found"); + return NULL; + } + + for(i=0; i<cfg->aliases->nelts; i++) { + alias_entry = APR_ARRAY_IDX(cfg->aliases,i,mapcache_alias_entry*); + if(strcmp(alias_entry->endpoint,mapcache_alias)) + continue; + + mctx->config = alias_entry->cfg; + ctx->request = r; + mctx->connection_pool = alias_entry->cp; + init_apache_request_context(ctx); + return ctx; + } + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mapcache module bug? no mapcache_alias_entry found for %s",mapcache_alias); + return NULL; } static mapcache_context_apache_server* apache_server_context_create(server_rec *s, apr_pool_t *pool) @@ -227,34 +261,36 @@ static void read_post_body(mapcache_context_apache_request *ctx, mapcache_reques } } else { bytes = p->rule->max_post_len; - } + } bb = apr_brigade_create(mctx->pool, r->connection->bucket_alloc); bbin = apr_brigade_create(mctx->pool, r->connection->bucket_alloc); p->post_len = 0; do { + apr_bucket *nextb; rv = ap_get_brigade(r->input_filters, bbin, AP_MODE_READBYTES, APR_BLOCK_READ, bytes); if(rv != APR_SUCCESS) { mctx->set_error(mctx, 500, "failed to read form input"); return; } - for(b = APR_BRIGADE_FIRST(bbin); b != APR_BRIGADE_SENTINEL(bbin); b = APR_BUCKET_NEXT(b)) { + for(b = APR_BRIGADE_FIRST(bbin); b != APR_BRIGADE_SENTINEL(bbin); b = nextb) { + nextb = APR_BUCKET_NEXT(b); if(APR_BUCKET_IS_EOS(b)) { eos = 1; } - } - if(!APR_BUCKET_IS_METADATA(b)) { - if(b->length != (apr_size_t)(-1)) { - p->post_len += b->length; - if(p->post_len > p->rule->max_post_len) { - apr_bucket_delete(b); + if(!APR_BUCKET_IS_METADATA(b)) { + if(b->length != (apr_size_t)(-1)) { + p->post_len += b->length; + if(p->post_len > p->rule->max_post_len) { + apr_bucket_delete(b); + } } } - } - if(p->post_len <= p->rule->max_post_len) { - APR_BUCKET_REMOVE(b); - APR_BRIGADE_INSERT_TAIL(bb, b); + if(p->post_len <= p->rule->max_post_len) { + APR_BUCKET_REMOVE(b); + APR_BRIGADE_INSERT_TAIL(bb, b); + } } } while (!eos); @@ -264,11 +300,13 @@ static void read_post_body(mapcache_context_apache_request *ctx, mapcache_reques } p->post_buf = apr_palloc(mctx->pool, p->post_len+1); - - rv = apr_brigade_flatten(bb, p->post_buf, &(p->post_len)); - if(rv != APR_SUCCESS) { - mctx->set_error(mctx, 500, "error (flatten) reading form data"); - return; + + if(p->post_len> 0) { + rv = apr_brigade_flatten(bb, p->post_buf, &(p->post_len)); + if(rv != APR_SUCCESS) { + mctx->set_error(mctx, 500, "error (flatten) reading form data"); + return; + } } p->post_buf[p->post_len] = 0; } @@ -312,15 +350,20 @@ static int write_http_response(mapcache_context_apache_request *ctx, mapcache_ht static void mod_mapcache_child_init(apr_pool_t *pool, server_rec *s) { - int rv; - mapcache_server_cfg* cfg = ap_get_module_config(s->module_config, &mapcache_module); #ifdef APR_HAS_THREADS apr_thread_mutex_create(&thread_mutex,APR_THREAD_MUTEX_DEFAULT,pool); #endif - rv = mapcache_connection_pool_create(&(cfg->cp),pool); - ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "creating a mapcache connection pool for server"); - if(rv!=APR_SUCCESS) { - ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "failed to create mapcache connection pool"); + for( ; s ; s=s->next) { + mapcache_server_cfg* cfg = ap_get_module_config(s->module_config, &mapcache_module); + int i,rv; + for(i=0;i<cfg->aliases->nelts;i++) { + mapcache_alias_entry *alias_entry = APR_ARRAY_IDX(cfg->aliases,i,mapcache_alias_entry*); + rv = mapcache_connection_pool_create(&(alias_entry->cp),pool); + ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "creating a child process mapcache connection pool on server %s for alias %s", s->server_hostname, alias_entry->endpoint); + if(rv!=APR_SUCCESS) { + ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "failed to create mapcache connection pool"); + } + } } } @@ -341,12 +384,19 @@ static int mod_mapcache_request_handler(request_rec *r) apache_ctx = apache_request_context_create(r); + + if(!apache_ctx) { + return DECLINED; + } + global_ctx = (mapcache_context*)apache_ctx; global_ctx->supports_redirects = 1; global_ctx->headers_in = r->headers_in; params = mapcache_http_parse_param_string(global_ctx, r->args); + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "mapcache dispatch %s",r->path_info); + mapcache_service_dispatch_request(global_ctx,&request,r->path_info,params,global_ctx->config); if(GC_HAS_ERROR(global_ctx) || !request) { return write_http_response(apache_ctx, @@ -417,7 +467,7 @@ static int mod_mapcache_request_handler(request_rec *r) apr_table_set(req_proxy->headers, "X-Forwarded-Host", buf); } } - + if ((buf = apr_table_get(r->headers_in, "X-Forwarded-Server"))) { apr_table_set(req_proxy->headers, "X-Forwarded-Server", apr_psprintf(global_ctx->pool, "%s, %s", buf, r->server->server_hostname)); } else { @@ -449,7 +499,6 @@ static int mod_mapcache_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "configuration not found in server context"); return 1; } - #ifdef USE_VERSION_STRING ap_add_version_component(p, MAPCACHE_USERAGENT); @@ -497,35 +546,35 @@ static int mapcache_alias_matches(const char *uri, const char *alias_fakename) return urip - uri; } -static int mapcache_hook_intercept(request_rec *r) +static int mapcache_hook_fixups(request_rec *r) { - mapcache_server_cfg *sconfig = ap_get_module_config(r->server->module_config, &mapcache_module); - apr_hash_index_t *entry; - - if (!sconfig->aliases) - return DECLINED; - - if (r->uri[0] != '/' && r->uri[0]) - return DECLINED; - - entry = apr_hash_first(r->pool,sconfig->aliases); - - /* loop through the entries to find one where the alias matches */ - while (entry) { - int l = 0; - const char *alias; - apr_ssize_t aliaslen; - mapcache_cfg *c; - apr_hash_this(entry,(const void**)&alias,&aliaslen,(void**)&c); - - if((l=mapcache_alias_matches(r->uri, c->endpoint))>0) { - r->handler = "mapcache"; - r->filename = c->configFile; - r->path_info = &(r->uri[l]); - return OK; + int i; + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "running mapcache fixup on %s (handler:%s,filename:%s)",r->uri,r->handler,r->filename); + if(!r->handler) { + mapcache_server_cfg *sconfig = ap_get_module_config(r->server->module_config, &mapcache_module); + mapcache_alias_entry *alias_entry; + + if (!sconfig || !sconfig->aliases) + return DECLINED; + + if (r->uri[0] != '/' && r->uri[0]) + return DECLINED; + + /* loop through the entries to find one where the alias matches */ + for(i=0; i<sconfig->aliases->nelts; i++) { + int l; + alias_entry = APR_ARRAY_IDX(sconfig->aliases,i,mapcache_alias_entry*); + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "cheking mapcache alias %s against %s",r->uri,alias_entry->endpoint); + + if((l=mapcache_alias_matches(r->uri, alias_entry->endpoint))>0) { + r->handler = apr_pstrdup(r->pool,"mapcache"); + apr_table_set(r->notes,"mapcache_alias_entry",alias_entry->endpoint); + r->path_info = &(r->uri[l]); + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "setting config %s for alias %s",alias_entry->configfile,alias_entry->endpoint); + //ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "using pathinfo %s from uri %s",r->path_info,r->uri); + return OK; + } } - - entry = apr_hash_next(entry); } return DECLINED; @@ -534,21 +583,17 @@ static int mapcache_hook_intercept(request_rec *r) static void mod_mapcache_register_hooks(apr_pool_t *p) { - static const char * const p1[] = { "mod_alias.c", "mod_rewrite.c", NULL }; - static const char * const n1[]= { "mod_userdir.c", - "mod_vhost_alias.c", NULL - }; ap_hook_child_init(mod_mapcache_child_init, NULL, NULL, APR_HOOK_MIDDLE); ap_hook_post_config(mod_mapcache_post_config, NULL, NULL, APR_HOOK_MIDDLE); ap_hook_handler(mod_mapcache_request_handler, NULL, NULL, APR_HOOK_MIDDLE); - ap_hook_translate_name(mapcache_hook_intercept, p1, n1, APR_HOOK_MIDDLE); + ap_hook_fixups(mapcache_hook_fixups, NULL, NULL, APR_HOOK_MIDDLE); } static void* mod_mapcache_create_server_conf(apr_pool_t *pool, server_rec *s) { mapcache_server_cfg *cfg = apr_pcalloc(pool, sizeof(mapcache_server_cfg)); - cfg->aliases = NULL; + cfg->aliases = apr_array_make(pool,1,sizeof(mapcache_alias_entry*)); return cfg; } @@ -559,38 +604,69 @@ static void *mod_mapcache_merge_server_conf(apr_pool_t *p, void *base_, void *vh mapcache_server_cfg *vhost = (mapcache_server_cfg*)vhost_; mapcache_server_cfg *cfg = apr_pcalloc(p,sizeof(mapcache_server_cfg)); - if (base->aliases && vhost->aliases) { - cfg->aliases = apr_hash_overlay(p, vhost->aliases,base->aliases); - } else if (vhost->aliases) { - cfg->aliases = apr_hash_copy(p,vhost->aliases); - } else if (base->aliases) { - cfg->aliases = apr_hash_copy(p,base->aliases); + cfg->aliases = apr_array_append(p, vhost->aliases,base->aliases); + +#if 0 + { + mapcache_alias_entry *e; + int i; + fprintf(stderr,"#### merge called ####\n"); + for(i=0;i<base->aliases->nelts;i++) { + e = APR_ARRAY_IDX(base->aliases,i,mapcache_alias_entry*); + fprintf(stderr,"merge base: have alias %s on %s\n",e->configfile,e->endpoint); + } + for(i=0;i<vhost->aliases->nelts;i++) { + e = APR_ARRAY_IDX(vhost->aliases,i,mapcache_alias_entry*); + fprintf(stderr,"merge vhosts: have alias %s on %s\n",e->configfile,e->endpoint); + } + for(i=0;i<cfg->aliases->nelts;i++) { + e = APR_ARRAY_IDX(cfg->aliases,i,mapcache_alias_entry*); + fprintf(stderr,"merge result: have alias %s on %s\n",e->configfile,e->endpoint); + } } - return vhost; +#endif + return cfg; } static const char* mapcache_add_alias(cmd_parms *cmd, void *cfg, const char *alias, const char* configfile) { - mapcache_server_cfg *sconfig = ap_get_module_config(cmd->server->module_config, &mapcache_module); - mapcache_cfg *config = mapcache_configuration_create(cmd->pool); - mapcache_context *ctx = (mapcache_context*)apache_server_context_create(cmd->server,cmd->pool); - char *msg = NULL; - config->configFile = apr_pstrdup(cmd->pool,configfile); - config->endpoint = alias; - mapcache_configuration_parse(ctx,configfile,config,0); + mapcache_server_cfg *sconfig; + mapcache_alias_entry *alias_entry; + mapcache_context *ctx; + unsigned forbidden = NOT_IN_DIRECTORY|NOT_IN_FILES; + const char *err; + +#if (AP_SERVER_MAJORVERSION_NUMBER > 2) || (AP_SERVER_MINORVERSION_NUMBER >= 4) + forbidden |= NOT_IN_HTACCESS; +#endif + + err = ap_check_cmd_context(cmd, forbidden); + if (err) { + return err; + } + + sconfig = ap_get_module_config(cmd->server->module_config, &mapcache_module); + if(!sconfig || !sconfig->aliases) + return "no mapcache module config, server bug?"; + + alias_entry = apr_pcalloc(cmd->pool,sizeof(mapcache_alias_entry)); + ctx = (mapcache_context*)apache_server_context_create(cmd->server,cmd->pool); + + alias_entry->cfg = mapcache_configuration_create(cmd->pool); + alias_entry->configfile = apr_pstrdup(cmd->pool,configfile); + alias_entry->endpoint = apr_pstrdup(cmd->pool,alias); + mapcache_configuration_parse(ctx,alias_entry->configfile,alias_entry->cfg,0); if(GC_HAS_ERROR(ctx)) { return ctx->get_error_message(ctx); } - mapcache_configuration_post_config(ctx, config); + mapcache_configuration_post_config(ctx, alias_entry->cfg); if(GC_HAS_ERROR(ctx)) { return ctx->get_error_message(ctx); } - ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server, "loaded mapcache configuration file from %s on alias %s", config->configFile, alias); - if(!sconfig->aliases) { - sconfig->aliases = apr_hash_make(cmd->pool); - } - apr_hash_set(sconfig->aliases,configfile,APR_HASH_KEY_STRING,config); - return msg; + APR_ARRAY_PUSH(sconfig->aliases,mapcache_alias_entry*) = alias_entry; + ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server, "loaded mapcache configuration file from %s on endpoint %s", alias_entry->configfile, alias_entry->endpoint); + + return NULL; } diff --git a/cgi/mapcache.c b/cgi/mapcache.c index e7b9c20..75557e9 100644 --- a/cgi/mapcache.c +++ b/cgi/mapcache.c @@ -128,6 +128,11 @@ static void fcgi_write_response(mapcache_context_fcgi *ctx, mapcache_http_respon if(response->mtime) { char *datestr; char *if_modified_since = getenv("HTTP_IF_MODIFIED_SINCE"); + + datestr = apr_palloc(ctx->ctx.pool, APR_RFC822_DATE_LEN); + apr_rfc822_date(datestr, response->mtime); + printf("Last-Modified: %s\r\n", datestr); + if(if_modified_since) { apr_time_t ims_time; apr_int64_t ims,mtime; @@ -138,11 +143,14 @@ static void fcgi_write_response(mapcache_context_fcgi *ctx, mapcache_http_respon ims = apr_time_sec(ims_time); if(ims >= mtime) { printf("Status: 304 Not Modified\r\n"); + /* + * "The 304 response MUST NOT contain a message-body" + * https://tools.ietf.org/html/rfc2616#section-10.3.5 + */ + printf("\r\n"); + return; } } - datestr = apr_palloc(ctx->ctx.pool, APR_RFC822_DATE_LEN); - apr_rfc822_date(datestr, response->mtime); - printf("Last-Modified: %s\r\n", datestr); } if(response->data) { printf("Content-Length: %ld\r\n\r\n", response->data->size); diff --git a/cmake/FindAPACHE.cmake b/cmake/FindAPACHE.cmake index dd4f80d..5bc7825 100644 --- a/cmake/FindAPACHE.cmake +++ b/cmake/FindAPACHE.cmake @@ -10,7 +10,7 @@ # find_path(APACHE_INCLUDE_DIR NAMES httpd.h - PATH_SUFFIXES httpd apache apache2 + PATH_SUFFIXES httpd apache apache2 apache22 apache24 ) if(NOT DEFINED APACHE_MODULE_DIR) diff --git a/include/mapcache.h b/include/mapcache.h index c4ed758..8f24326 100644 --- a/include/mapcache.h +++ b/include/mapcache.h @@ -90,7 +90,11 @@ #define MAPCACHE_USERAGENT "mod-mapcache/"MAPCACHE_VERSION - +#if defined(_WIN32) && !defined(__CYGWIN__) +# define MS_DLL_EXPORT __declspec(dllexport) +#else +#define MS_DLL_EXPORT +#endif typedef struct mapcache_image_format mapcache_image_format; @@ -219,13 +223,13 @@ struct mapcache_context { * \memberof mapcache_context */ void (*clear_errors)(mapcache_context * ctx); - + /** * \brief clear current error and store it in mapcache_error * \memberof mapcache_context */ void (*pop_errors)(mapcache_context * ctx, void **error); - + /** * \brief restore error status from mapcache_error * \memberof mapcache_context @@ -254,8 +258,8 @@ struct mapcache_context { apr_table_t *headers_in; }; -void mapcache_context_init(mapcache_context *ctx); -void mapcache_context_copy(mapcache_context *src, mapcache_context *dst); +MS_DLL_EXPORT void mapcache_context_init(mapcache_context *ctx); +MS_DLL_EXPORT void mapcache_context_copy(mapcache_context *src, mapcache_context *dst); #define GC_CHECK_ERROR_RETURN(ctx) if(((mapcache_context*)ctx)->_errcode) return MAPCACHE_FAILURE; #define GC_CHECK_ERROR(ctx) if(((mapcache_context*)ctx)->_errcode) return; @@ -511,7 +515,7 @@ typedef enum { MAPCACHE_REST_PROVIDER_NONE, MAPCACHE_REST_PROVIDER_S3, MAPCACHE_REST_PROVIDER_AZURE, - MAPCACHE_REST_PROVIDER_GOOGLE, + MAPCACHE_REST_PROVIDER_GOOGLE } mapcache_rest_provider; void sha256(const unsigned char *message, unsigned int len, unsigned char *digest); @@ -1041,7 +1045,7 @@ mapcache_service* mapcache_service_demo_create(mapcache_context *ctx); /** * \brief return the request that corresponds to the given url */ -void mapcache_service_dispatch_request(mapcache_context *ctx, +MS_DLL_EXPORT void mapcache_service_dispatch_request(mapcache_context *ctx, mapcache_request **request, char *pathinfo, apr_table_t *params, @@ -1147,17 +1151,13 @@ void mapcache_image_fill(mapcache_context *ctx, mapcache_image *image, const uns /** @{ */ void mapcache_http_do_request(mapcache_context *ctx, mapcache_http *req, mapcache_buffer *data, apr_table_t *headers, long *http_code); char* mapcache_http_build_url(mapcache_context *ctx, char *base, apr_table_t *params); -apr_table_t *mapcache_http_parse_param_string(mapcache_context *ctx, char *args); +MS_DLL_EXPORT apr_table_t *mapcache_http_parse_param_string(mapcache_context *ctx, char *args); /** @} */ /** \defgroup configuration Configuration*/ /** @{ */ -struct mapcache_server_cfg { - apr_hash_t *aliases; /**< list of mapcache configurations aliased to a server uri */ - mapcache_connection_pool *cp; -}; @@ -1184,7 +1184,7 @@ struct mapcache_locker{ mapcache_lock_result (*aquire_lock)(mapcache_context *ctx, mapcache_locker *self, char *resource, void **lock); mapcache_lock_result (*ping_lock)(mapcache_context *ctx, mapcache_locker *self, char *resource, void *lock); void (*release_lock)(mapcache_context *ctx, mapcache_locker *self, char *resource, void *lock); - + void (*parse_xml)(mapcache_context *ctx, mapcache_locker *self, ezxml_t node); mapcache_lock_mode type; double timeout; @@ -1233,8 +1233,6 @@ void mapcache_config_parse_locker(mapcache_context *ctx, ezxml_t node, mapcache_ * a configuration that will be served */ struct mapcache_cfg { - char *configFile; /**< the filename from which this configuration was loaded */ - /** * a list of services that will be responded to */ @@ -1290,11 +1288,6 @@ struct mapcache_cfg { int threaded_fetching; - /** - * the uri where the base of the service is mapped - */ - const char *endpoint; - /* for fastcgi only */ int autoreload; /* should the modification time of the config file be recorded and the file be reparsed if it is modified. */ @@ -1315,14 +1308,14 @@ struct mapcache_cfg { * @param pool * @return */ -void mapcache_configuration_parse(mapcache_context *ctx, const char *filename, mapcache_cfg *config, int cgi); -void mapcache_configuration_post_config(mapcache_context *ctx, mapcache_cfg *config); +MS_DLL_EXPORT void mapcache_configuration_parse(mapcache_context *ctx, const char *filename, mapcache_cfg *config, int cgi); +MS_DLL_EXPORT void mapcache_configuration_post_config(mapcache_context *ctx, mapcache_cfg *config); void mapcache_configuration_parse_xml(mapcache_context *ctx, const char *filename, mapcache_cfg *config); -mapcache_cfg* mapcache_configuration_create(apr_pool_t *pool); +MS_DLL_EXPORT mapcache_cfg* mapcache_configuration_create(apr_pool_t *pool); mapcache_source* mapcache_configuration_get_source(mapcache_cfg *config, const char *key); -mapcache_cache* mapcache_configuration_get_cache(mapcache_cfg *config, const char *key); +MS_DLL_EXPORT mapcache_cache* mapcache_configuration_get_cache(mapcache_cfg *config, const char *key); mapcache_grid *mapcache_configuration_get_grid(mapcache_cfg *config, const char *key); -mapcache_tileset* mapcache_configuration_get_tileset(mapcache_cfg *config, const char *key); +MS_DLL_EXPORT mapcache_tileset* mapcache_configuration_get_tileset(mapcache_cfg *config, const char *key); mapcache_image_format *mapcache_configuration_get_image_format(mapcache_cfg *config, const char *key); void mapcache_configuration_add_image_format(mapcache_cfg *config, mapcache_image_format *format, const char * key); void mapcache_configuration_add_source(mapcache_cfg *config, mapcache_source *source, const char * key); @@ -1446,7 +1439,7 @@ typedef enum { MAPCACHE_GRID_ORIGIN_BOTTOM_LEFT, MAPCACHE_GRID_ORIGIN_TOP_LEFT, MAPCACHE_GRID_ORIGIN_BOTTOM_RIGHT, - MAPCACHE_GRID_ORIGIN_TOP_RIGHT, + MAPCACHE_GRID_ORIGIN_TOP_RIGHT } mapcache_grid_origin; struct mapcache_grid { @@ -1478,7 +1471,7 @@ struct mapcache_grid_link { mapcache_extent *restricted_extent; mapcache_extent_i *grid_limits; int minz,maxz; - + /** * tiles above this zoom level will not be stored to the cache, but will be * dynamically generated (either by reconstructing from lower level tiles, or @@ -1620,13 +1613,13 @@ void mapcache_tileset_tile_validate(mapcache_context *ctx, mapcache_tile *tile); void mapcache_tileset_get_level(mapcache_context *ctx, mapcache_tileset *tileset, double *resolution, int *level); mapcache_grid_link* mapcache_grid_get_closest_wms_level(mapcache_context *ctx, mapcache_grid_link *grid, double resolution, int *level); -void mapcache_tileset_tile_get(mapcache_context *ctx, mapcache_tile *tile); +MS_DLL_EXPORT void mapcache_tileset_tile_get(mapcache_context *ctx, mapcache_tile *tile); /** * \brief delete tile from cache * @param whole_metatile delete all the other tiles from the metatile to */ -void mapcache_tileset_tile_delete(mapcache_context *ctx, mapcache_tile *tile, int whole_metatile); +MS_DLL_EXPORT void mapcache_tileset_tile_delete(mapcache_context *ctx, mapcache_tile *tile, int whole_metatile); int mapcache_grid_is_bbox_aligned(mapcache_context *ctx, mapcache_grid *grid, mapcache_extent *bbox); @@ -1637,7 +1630,7 @@ int mapcache_grid_is_bbox_aligned(mapcache_context *ctx, mapcache_grid *grid, ma * @param pool * @return */ -mapcache_tile* mapcache_tileset_tile_create(apr_pool_t *pool, mapcache_tileset *tileset, mapcache_grid_link *grid_link); +MS_DLL_EXPORT mapcache_tile* mapcache_tileset_tile_create(apr_pool_t *pool, mapcache_tileset *tileset, mapcache_grid_link *grid_link); mapcache_tile* mapcache_tileset_tile_clone(apr_pool_t *pool, mapcache_tile *src); @@ -1670,27 +1663,27 @@ void mapcache_tileset_configuration_check(mapcache_context *ctx, mapcache_tilese void mapcache_tileset_add_watermark(mapcache_context *ctx, mapcache_tileset *tileset, const char *filename); -int mapcache_lock_or_wait_for_resource(mapcache_context *ctx, mapcache_locker *locker, char *resource, void **lock); -void mapcache_unlock_resource(mapcache_context *ctx, mapcache_locker *locker, char *resource, void *lock); +MS_DLL_EXPORT int mapcache_lock_or_wait_for_resource(mapcache_context *ctx, mapcache_locker *locker, char *resource, void **lock); +MS_DLL_EXPORT void mapcache_unlock_resource(mapcache_context *ctx, mapcache_locker *locker, char *resource, void *lock); -mapcache_metatile* mapcache_tileset_metatile_get(mapcache_context *ctx, mapcache_tile *tile); -void mapcache_tileset_render_metatile(mapcache_context *ctx, mapcache_metatile *mt); -char* mapcache_tileset_metatile_resource_key(mapcache_context *ctx, mapcache_metatile *mt); +MS_DLL_EXPORT mapcache_metatile* mapcache_tileset_metatile_get(mapcache_context *ctx, mapcache_tile *tile); +MS_DLL_EXPORT void mapcache_tileset_render_metatile(mapcache_context *ctx, mapcache_metatile *mt); +MS_DLL_EXPORT char* mapcache_tileset_metatile_resource_key(mapcache_context *ctx, mapcache_metatile *mt); /** @} */ -mapcache_http_response* mapcache_core_get_capabilities(mapcache_context *ctx, mapcache_service *service, mapcache_request_get_capabilities *req_caps, char *url, char *path_info, mapcache_cfg *config); -mapcache_http_response* mapcache_core_get_tile(mapcache_context *ctx, mapcache_request_get_tile *req_tile); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_get_capabilities(mapcache_context *ctx, mapcache_service *service, mapcache_request_get_capabilities *req_caps, char *url, char *path_info, mapcache_cfg *config); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_get_tile(mapcache_context *ctx, mapcache_request_get_tile *req_tile); -mapcache_http_response* mapcache_core_get_map(mapcache_context *ctx, mapcache_request_get_map *req_map); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_get_map(mapcache_context *ctx, mapcache_request_get_map *req_map); -mapcache_http_response* mapcache_core_get_featureinfo(mapcache_context *ctx, mapcache_request_get_feature_info *req_fi); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_get_featureinfo(mapcache_context *ctx, mapcache_request_get_feature_info *req_fi); -mapcache_http_response* mapcache_core_proxy_request(mapcache_context *ctx, mapcache_request_proxy *req_proxy); -mapcache_http_response* mapcache_core_respond_to_error(mapcache_context *ctx); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_proxy_request(mapcache_context *ctx, mapcache_request_proxy *req_proxy); +MS_DLL_EXPORT mapcache_http_response* mapcache_core_respond_to_error(mapcache_context *ctx); /* in grid.c */ @@ -1699,7 +1692,7 @@ mapcache_grid* mapcache_grid_create(apr_pool_t *pool); const char* mapcache_grid_get_crs(mapcache_context *ctx, mapcache_grid *grid); const char* mapcache_grid_get_srs(mapcache_context *ctx, mapcache_grid *grid); -void mapcache_grid_get_extent(mapcache_context *ctx, mapcache_grid *grid, +MS_DLL_EXPORT void mapcache_grid_get_extent(mapcache_context *ctx, mapcache_grid *grid, int x, int y, int z, mapcache_extent *bbox); /** * \brief compute x y value for given lon/lat (dx/dy) and given zoomlevel @@ -1711,7 +1704,7 @@ void mapcache_grid_get_extent(mapcache_context *ctx, mapcache_grid *grid, * @param x * @param y */ -void mapcache_grid_get_xy(mapcache_context *ctx, mapcache_grid *grid, double dx, double dy, int z, int *x, int *y); +MS_DLL_EXPORT void mapcache_grid_get_xy(mapcache_context *ctx, mapcache_grid *grid, double dx, double dy, int z, int *x, int *y); double mapcache_grid_get_resolution(mapcache_extent *bbox, int sx, int sy); double mapcache_grid_get_horizontal_resolution(mapcache_extent *bbox, int width); @@ -1731,12 +1724,12 @@ int mapcache_grid_get_level(mapcache_context *ctx, mapcache_grid *grid, double * * \param extent * \param tolerance the number of tiles around the given extent that can be requested without returning an error. */ -void mapcache_grid_compute_limits(const mapcache_grid *grid, const mapcache_extent *extent, mapcache_extent_i *limits, int tolerance); +MS_DLL_EXPORT void mapcache_grid_compute_limits(const mapcache_grid *grid, const mapcache_extent *extent, mapcache_extent_i *limits, int tolerance); /* in util.c */ -int mapcache_util_extract_int_list(mapcache_context *ctx, const char* args, const char *sep, int **numbers, +MS_DLL_EXPORT int mapcache_util_extract_int_list(mapcache_context *ctx, const char* args, const char *sep, int **numbers, int *numbers_count); -int mapcache_util_extract_double_list(mapcache_context *ctx, const char* args, const char *sep, double **numbers, +MS_DLL_EXPORT int mapcache_util_extract_double_list(mapcache_context *ctx, const char* args, const char *sep, double **numbers, int *numbers_count); char *mapcache_util_str_replace(apr_pool_t *pool, const char *string, const char *substr, const char *replacement ); @@ -1755,6 +1748,7 @@ char* mapcache_util_get_tile_dimkey(mapcache_context *ctx, mapcache_tile *tile, char* mapcache_util_get_tile_key(mapcache_context *ctx, mapcache_tile *tile, char *stemplate, char* sanitized_chars, char *sanitize_to); +void mapcache_make_parent_dirs(mapcache_context *ctx, char *filename); /**\defgroup imageio Image IO */ /** @{ */ @@ -2026,13 +2020,13 @@ typedef enum { MAPCACHE_TIMEDIMENSION_SOURCE_SQLITE } mapcache_timedimension_source_type; -apr_array_header_t* mapcache_timedimension_get_entries_for_value(mapcache_context *ctx, mapcache_timedimension *timedimesnion, +MS_DLL_EXPORT apr_array_header_t* mapcache_timedimension_get_entries_for_value(mapcache_context *ctx, mapcache_timedimension *timedimesnion, mapcache_tileset *tileset, mapcache_grid *grid, mapcache_extent *extent, const char *value); struct mapcache_timedimension { mapcache_timedimension_assembly_type assembly_type; void (*configuration_parse_xml)(mapcache_context *context, mapcache_timedimension *dim, ezxml_t node); - apr_array_header_t* (*get_entries_for_interval)(mapcache_context *ctx, mapcache_timedimension *dim, mapcache_tileset *tileset, + apr_array_header_t* (*get_entries_for_interval)(mapcache_context *ctx, mapcache_timedimension *dim, mapcache_tileset *tileset, mapcache_grid *grid, mapcache_extent *extent, time_t start, time_t end); apr_array_header_t* (*get_all_entries)(mapcache_context *ctx, mapcache_timedimension *dim, mapcache_tileset *tileset); char *default_value; @@ -2060,10 +2054,10 @@ struct mapcache_pooled_connection { void *connection; }; -typedef void (*mapcache_connection_constructor)(mapcache_context *ctx, void **connection, void *params, apr_pool_t *process_pool); -typedef void (*mapcache_connection_destructor)(void *connection, apr_pool_t *process_pool); +typedef void (*mapcache_connection_constructor)(mapcache_context *ctx, void **connection, void *params); +typedef void (*mapcache_connection_destructor)(void *connection); -apr_status_t mapcache_connection_pool_create(mapcache_connection_pool **cp, apr_pool_t *server_pool); +MS_DLL_EXPORT apr_status_t mapcache_connection_pool_create(mapcache_connection_pool **cp, apr_pool_t *server_pool); mapcache_pooled_connection* mapcache_connection_pool_get_connection(mapcache_context *ctx, char *key, mapcache_connection_constructor constructor, mapcache_connection_destructor destructor, diff --git a/include/util.h b/include/util.h index 4f95592..1be2354 100644 --- a/include/util.h +++ b/include/util.h @@ -87,13 +87,19 @@ APR_DECLARE(apr_table_t *) apr_table_clone(apr_pool_t *p, #endif #endif +#if defined(_WIN32) && !defined(__CYGWIN__) +# define MS_DLL_EXPORT __declspec(dllexport) +#else +#define MS_DLL_EXPORT +#endif #if defined(_WIN32) struct mctimeval { long tv_sec; /* seconds */ long tv_usec; /* and microseconds */ }; -void mapcache_gettimeofday(struct mctimeval *t, void *__not_used_here__); +MS_DLL_EXPORT void mapcache_gettimeofday(struct mctimeval *t, void *__not_used_here__); +MS_DLL_EXPORT char * strptime (const char *buf, const char *format, struct tm *timeptr); #else # include <sys/time.h> /* for gettimeofday() */ # define mctimeval timeval diff --git a/lib/cache_bdb.c b/lib/cache_bdb.c index fd40d43..a45ca4b 100644 --- a/lib/cache_bdb.c +++ b/lib/cache_bdb.c @@ -58,56 +58,60 @@ struct bdb_env { char *errmsg; }; -void mapcache_bdb_connection_constructor(mapcache_context *ctx, void **conn_, void *params, apr_pool_t *pool) +void mapcache_bdb_connection_constructor(mapcache_context *ctx, void **conn_, void *params) { int ret; int env_flags; int mode; mapcache_cache_bdb *cache = (mapcache_cache_bdb*)params; - char *dbfile = apr_pstrcat(pool,cache->basedir,"/",cache->cache.name,".db",NULL); + char *dbfile = malloc(strlen(cache->basedir)+strlen(cache->cache.name)+strlen("/.db")+1); struct bdb_env *benv = calloc(1,sizeof(struct bdb_env)); + dbfile[0]=0; + strcat(strcat(strcat(strcat(dbfile,cache->basedir),"/"),cache->cache.name),".db"); /*yuk yuk*/ *conn_ = benv; ret = db_env_create(&benv->env, 0); if(ret) { ctx->set_error(ctx, 500, "bdb cache failure for db_env_create: %s", db_strerror(ret)); - free(benv); - return; + goto cleanup_error; } ret = benv->env->set_cachesize(benv->env,0,CACHESIZE,1); /* set a larger cache size than default */ if(ret) { ctx->set_error(ctx, 500, "bdb cache failure for db->set_cachesize: %s", db_strerror(ret)); - free(benv); - return; + goto cleanup_error; } env_flags = DB_INIT_CDB|DB_INIT_MPOOL|DB_CREATE; ret = benv->env->open(benv->env,cache->basedir,env_flags,0); if(ret) { ctx->set_error(ctx,500,"bdb cache failure for env->open: %s", db_strerror(ret)); - free(benv); - return; + goto cleanup_error; } if ((ret = db_create(&benv->db, benv->env, 0)) != 0) { ctx->set_error(ctx,500,"bdb cache failure for db_create: %s", db_strerror(ret)); - free(benv); + goto cleanup_error; } mode = DB_BTREE; ret = benv->db->set_pagesize(benv->db,PAGESIZE); /* set pagesize to maximum allowed, as tile data is usually pretty large */ if(ret) { ctx->set_error(ctx,500,"bdb cache failure for db->set_pagesize: %s", db_strerror(ret)); - free(benv); - return; + goto cleanup_error; } if ((ret = benv->db->open(benv->db, NULL, dbfile, NULL, mode, DB_CREATE, 0664)) != 0) { ctx->set_error(ctx,500,"bdb cache failure 1 for db->open: %s", db_strerror(ret)); - free(benv); - return; + goto cleanup_error; } + + goto cleanup; + +cleanup_error: + free(benv); +cleanup: + free(dbfile); } -void mapcache_bdb_connection_destructor(void *conn_, apr_pool_t *pool) +void mapcache_bdb_connection_destructor(void *conn_) { struct bdb_env *benv = (struct bdb_env*)conn_; benv->db->close(benv->db,0); @@ -144,7 +148,7 @@ static int _mapcache_cache_bdb_has_tile(mapcache_context *ctx, mapcache_cache *p mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache; char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL); mapcache_pooled_connection *pc; - struct bdb_env *benv; + struct bdb_env *benv; pc = _bdb_get_conn(ctx,cache,tile,1); if(GC_HAS_ERROR(ctx)) return MAPCACHE_FALSE; benv = pc->connection; @@ -173,7 +177,7 @@ static void _mapcache_cache_bdb_delete(mapcache_context *ctx, mapcache_cache *pc mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache; char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL); mapcache_pooled_connection *pc; - struct bdb_env *benv; + struct bdb_env *benv; pc = _bdb_get_conn(ctx,cache,tile,0); GC_CHECK_ERROR(ctx); benv = pc->connection; @@ -195,13 +199,14 @@ static int _mapcache_cache_bdb_get(mapcache_context *ctx, mapcache_cache *pcache { DBT key,data; int ret; + char *skey; mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache; mapcache_pooled_connection *pc; - struct bdb_env *benv; + struct bdb_env *benv; pc = _bdb_get_conn(ctx,cache,tile,1); if(GC_HAS_ERROR(ctx)) return MAPCACHE_FALSE; benv = pc->connection; - char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL); + skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL); memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); data.flags = DB_DBT_MALLOC; @@ -242,7 +247,7 @@ static void _mapcache_cache_bdb_set(mapcache_context *ctx, mapcache_cache *pcach mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache; char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL); mapcache_pooled_connection *pc; - struct bdb_env *benv; + struct bdb_env *benv; now = apr_time_now(); memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); @@ -254,7 +259,7 @@ static void _mapcache_cache_bdb_set(mapcache_context *ctx, mapcache_cache *pcach tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data); GC_CHECK_ERROR(ctx); } - + if(tile->raw_image->h==256 && tile->raw_image->w==256 && mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) { data.size = 5+sizeof(apr_time_t); data.data = apr_palloc(ctx->pool,data.size); @@ -271,7 +276,7 @@ static void _mapcache_cache_bdb_set(mapcache_context *ctx, mapcache_cache *pcach data.size = tile->encoded_data->size; tile->encoded_data->size -= sizeof(apr_time_t); } - + pc = _bdb_get_conn(ctx,cache,tile,0); GC_CHECK_ERROR(ctx); benv = pc->connection; @@ -295,7 +300,7 @@ static void _mapcache_cache_bdb_multiset(mapcache_context *ctx, mapcache_cache * apr_time_t now; mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache; mapcache_pooled_connection *pc; - struct bdb_env *benv; + struct bdb_env *benv; now = apr_time_now(); memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); @@ -303,7 +308,7 @@ static void _mapcache_cache_bdb_multiset(mapcache_context *ctx, mapcache_cache * pc = _bdb_get_conn(ctx,cache,&tiles[0],0); GC_CHECK_ERROR(ctx); benv = pc->connection; - + for(i=0; i<ntiles; i++) { char *skey; mapcache_tile *tile; diff --git a/lib/cache_disk.c b/lib/cache_disk.c index 304e21c..2ffbb0a 100644 --- a/lib/cache_disk.c +++ b/lib/cache_disk.c @@ -442,7 +442,7 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac apr_file_t *f; apr_status_t ret; char errmsg[120]; - char *filename, *hackptr1, *hackptr2=NULL; + char *filename; mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache; const int creation_retry = cache->creation_retry; int retry_count_create_file = 0; @@ -462,26 +462,8 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac cache->tile_key(ctx, cache, tile, &filename); GC_CHECK_ERROR(ctx); - /* find the location of the last '/' in the string */ - hackptr1 = filename; - while(*hackptr1) { - if(*hackptr1 == '/') - hackptr2 = hackptr1; - hackptr1++; - } - *hackptr2 = '\0'; - - if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) { - /* - * apr_dir_make_recursive sometimes sends back this error, although it should not. - * ignore this one - */ - if(!APR_STATUS_IS_EEXIST(ret)) { - ctx->set_error(ctx, 500, "failed to create directory %s: %s",filename, apr_strerror(ret,errmsg,120)); - return; - } - } - *hackptr2 = '/'; + mapcache_make_parent_dirs(ctx,filename); + GC_CHECK_ERROR(ctx); ret = apr_file_remove(filename,ctx->pool); if(ret != APR_SUCCESS && !APR_STATUS_IS_ENOENT(ret)) { @@ -497,26 +479,19 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac } if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) { char *blankname; + int retry_count_create_symlink = 0; + char *blankname_rel = NULL; _mapcache_cache_disk_blank_tile_key(ctx,cache,tile,tile->raw_image->data,&blankname); if(apr_file_open(&f, blankname, APR_FOPEN_READ, APR_OS_DEFAULT, ctx->pool) != APR_SUCCESS) { + /* create the blank file */ int isLocked; void *lock; if(!tile->encoded_data) { tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format); GC_CHECK_ERROR(ctx); } - /* create the blank file */ - char *blankdirname = apr_psprintf(ctx->pool, "%s/%s/%s/blanks", - cache->base_directory, - tile->tileset->name, - tile->grid_link->grid->name); - if(APR_SUCCESS != (ret = apr_dir_make_recursive( - blankdirname, APR_OS_DEFAULT,ctx->pool))) { - if(!APR_STATUS_IS_EEXIST(ret)) { - ctx->set_error(ctx, 500, "failed to create directory %s for blank tiles",blankdirname, apr_strerror(ret,errmsg,120)); - return; - } - } + mapcache_make_parent_dirs(ctx,blankname); + GC_CHECK_ERROR(ctx); /* aquire a lock on the blank file */ isLocked = mapcache_lock_or_wait_for_resource(ctx,ctx->config->locker,blankname, &lock); @@ -554,12 +529,10 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac apr_file_close(f); } - int retry_count_create_symlink = 0; /* * compute the relative path between tile and blank tile */ - char *blankname_rel = NULL; blankname_rel = relative_path(ctx,filename, blankname); GC_CHECK_ERROR(ctx); @@ -576,17 +549,8 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac ctx->set_error(ctx, 500, "failed to link tile %s to %s: %s",filename, blankname_rel, error); return; /* we could not create the file */ } - - *hackptr2 = '\0'; - - if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) { - if(!APR_STATUS_IS_EEXIST(ret)) { - ctx->set_error(ctx, 500, "failed to create symlink, can not create directory %s: %s",filename, apr_strerror(ret,errmsg,120)); - return; /* we could not create the file */ - } - } - - *hackptr2 = '/'; + mapcache_make_parent_dirs(ctx,filename); + GC_CHECK_ERROR(ctx); } #ifdef DEBUG ctx->log(ctx, MAPCACHE_DEBUG, "linked blank tile %s to %s",filename,blankname); @@ -618,17 +582,8 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac ctx->set_error(ctx, 500, "failed to create file %s: %s",filename, apr_strerror(ret,errmsg,120)); return; /* we could not create the file */ } - - *hackptr2 = '\0'; - - if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) { - if(!APR_STATUS_IS_EEXIST(ret)) { - ctx->set_error(ctx, 500, "failed to create file, can not create directory %s: %s",filename, apr_strerror(ret,errmsg,120)); - return; /* we could not create the file */ - } - } - - *hackptr2 = '/'; + mapcache_make_parent_dirs(ctx,filename); + GC_CHECK_ERROR(ctx); } bytes = (apr_size_t)tile->encoded_data->size; diff --git a/lib/cache_fallback.c b/lib/cache_fallback.c index 885ee30..28c3c47 100644 --- a/lib/cache_fallback.c +++ b/lib/cache_fallback.c @@ -64,13 +64,13 @@ static int _mapcache_cache_fallback_tile_get(mapcache_context *ctx, mapcache_cac if(ret == MAPCACHE_FAILURE) { int first_error = ctx->get_error(ctx); char *first_error_message = ctx->get_error_message(ctx); - ctx->log(ctx,MAPCACHE_WARN,"failed \"GET\" on primary cache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\". Falling back on secondary caches", + ctx->log(ctx,MAPCACHE_DEBUG,"failed \"GET\" on primary cache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\". Falling back on secondary caches", APR_ARRAY_IDX(cache->caches,0,mapcache_cache*)->name,tile->z,tile->x,tile->y,tile->tileset->name); ctx->clear_errors(ctx); for(i=1; i<cache->caches->nelts; i++) { subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*); if((ret = subcache->tile_get(ctx, subcache, tile)) == MAPCACHE_FAILURE) { - ctx->log(ctx,MAPCACHE_WARN,"failed \"GET\" on fallback cache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\". Continuing with other fallback caches if available", + ctx->log(ctx,MAPCACHE_DEBUG,"failed \"GET\" on fallback cache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\". Continuing with other fallback caches if available", APR_ARRAY_IDX(cache->caches,0,mapcache_cache*)->name,tile->z,tile->x,tile->y,tile->tileset->name); ctx->clear_errors(ctx); continue; @@ -100,7 +100,7 @@ static void _mapcache_cache_fallback_tile_set(mapcache_context *ctx, mapcache_ca first_error = ctx->get_error(ctx); first_error_message = ctx->get_error_message(ctx); } - ctx->log(ctx,MAPCACHE_WARN,"failed \"SET\" on subcache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\"", + ctx->log(ctx,MAPCACHE_DEBUG,"failed \"SET\" on subcache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\"", APR_ARRAY_IDX(cache->caches,i,mapcache_cache*)->name,tile->z,tile->x,tile->y,tile->tileset->name); ctx->clear_errors(ctx); } else { @@ -135,7 +135,7 @@ static void _mapcache_cache_fallback_tile_multi_set(mapcache_context *ctx, mapca first_error = ctx->get_error(ctx); first_error_message = ctx->get_error_message(ctx); } - ctx->log(ctx,MAPCACHE_WARN,"failed \"MULTISET\" on subcache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\"", + ctx->log(ctx,MAPCACHE_DEBUG,"failed \"MULTISET\" on subcache \"%s\" for tile (z=%d,x=%d,y=%d) of tileset \"%s\"", APR_ARRAY_IDX(cache->caches,i,mapcache_cache*)->name,tiles[0].z,tiles[0].x,tiles[0].y,tiles[0].tileset->name); ctx->clear_errors(ctx); } else { diff --git a/lib/cache_memcache.c b/lib/cache_memcache.c index f6d3334..a5d1a71 100644 --- a/lib/cache_memcache.c +++ b/lib/cache_memcache.c @@ -40,13 +40,13 @@ struct mapcache_memcache_pooled_connection { apr_pool_t *pool; }; -void mapcache_memcache_connection_constructor(mapcache_context *ctx, void **conn_, void *params, apr_pool_t *process_pool) { +void mapcache_memcache_connection_constructor(mapcache_context *ctx, void **conn_, void *params) { struct mapcache_memcache_conn_param *param = params; mapcache_cache_memcache *cache = param->cache; struct mapcache_memcache_pooled_connection *pc; int i; pc = calloc(1,sizeof(struct mapcache_memcache_pooled_connection)); - apr_pool_create(&pc->pool,process_pool); + apr_pool_create(&pc->pool,NULL); if(APR_SUCCESS != apr_memcache_create(pc->pool, cache->nservers, 0, &(pc->memcache))) { ctx->set_error(ctx,500,"cache %s: failed to create memcache backend", cache->cache.name); return; @@ -65,7 +65,7 @@ void mapcache_memcache_connection_constructor(mapcache_context *ctx, void **conn *conn_ = pc; } -void mapcache_memcache_connection_destructor(void *conn_, apr_pool_t *process_pool) { +void mapcache_memcache_connection_destructor(void *conn_) { struct mapcache_memcache_pooled_connection *pc = conn_; apr_pool_destroy(pc->pool); free(pc); @@ -186,7 +186,7 @@ static int _mapcache_cache_memcache_get(mapcache_context *ctx, mapcache_cache *p &(((char*)encoded_data->buf)[encoded_data->size-sizeof(apr_time_t)]), sizeof(apr_time_t)); - ((char*)encoded_data->buf)[encoded_data->size+sizeof(apr_time_t)]='\0'; + ((char*)encoded_data->buf)[encoded_data->size-sizeof(apr_time_t)]='\0'; encoded_data->avail = encoded_data->size; encoded_data->size -= sizeof(apr_time_t); if(((char*)encoded_data->buf)[0] == '#' && encoded_data->size > 1) { @@ -213,10 +213,11 @@ cleanup: */ static void _mapcache_cache_memcache_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) { - char *key; + char *key, *data; int rv; /* set no expiration if not configured */ int expires =0; + apr_time_t now; mapcache_buffer *encoded_data = NULL; mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache; mapcache_pooled_connection *pc; @@ -252,8 +253,8 @@ static void _mapcache_cache_memcache_set(mapcache_context *ctx, mapcache_cache * /* concatenate the current time to the end of the memcache data so we can extract it out * when we re-get the tile */ - char *data = calloc(1,encoded_data->size+sizeof(apr_time_t)); - apr_time_t now = apr_time_now(); + data = calloc(1,encoded_data->size+sizeof(apr_time_t)); + now = apr_time_now(); apr_pool_cleanup_register(ctx->pool, data, (void*)free, apr_pool_cleanup_null); memcpy(data,encoded_data->buf,encoded_data->size); memcpy(&(data[encoded_data->size]),&now,sizeof(apr_time_t)); diff --git a/lib/cache_multitier.c b/lib/cache_multitier.c index 9741191..44ea853 100644 --- a/lib/cache_multitier.c +++ b/lib/cache_multitier.c @@ -83,7 +83,7 @@ static int _mapcache_cache_multitier_tile_get(mapcache_context *ctx, mapcache_ca } return MAPCACHE_CACHE_MISS; } else { - ctx->log(ctx,MAPCACHE_DEBUG,"got tile (%s,z=%d,y=%d,x=%d) from primary cache (%s)",tile->tileset->name, tile->z, tile->y, tile->x, subcache->name); + //ctx->log(ctx,MAPCACHE_DEBUG,"got tile (%s,z=%d,y=%d,x=%d) from primary cache (%s)",tile->tileset->name, tile->z, tile->y, tile->x, subcache->name); return ret; } } diff --git a/lib/cache_rest.c b/lib/cache_rest.c index cb6adfb..401fd46 100644 --- a/lib/cache_rest.c +++ b/lib/cache_rest.c @@ -86,7 +86,7 @@ static void _put_request(mapcache_context *ctx, CURL *curl, mapcache_buffer *buf response = mapcache_buffer_create(10,ctx->pool); #if LIBCURL_VERSION_NUM < 0x071700 - /* + /* * hack around a bug in curl <= 7.22 where the content-length is added * a second time even if ti was present in the manually set headers */ @@ -97,35 +97,35 @@ static void _put_request(mapcache_context *ctx, CURL *curl, mapcache_buffer *buf curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); - /* we want to use our own read function */ + /* we want to use our own read function */ curl_easy_setopt(curl, CURLOPT_READFUNCTION, buffer_read_callback); - /* enable uploading */ + /* enable uploading */ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L); - /* HTTP PUT please */ + /* HTTP PUT please */ curl_easy_setopt(curl, CURLOPT_PUT, 1L); /* specify target URL, and note that this URL should include a file - * name, not only a directory */ + * name, not only a directory */ curl_easy_setopt(curl, CURLOPT_URL, url); - /* now specify which file to upload */ + /* now specify which file to upload */ curl_easy_setopt(curl, CURLOPT_READDATA, &data); /* provide the size of the upload, we specicially typecast the value - * to curl_off_t since we must be sure to use the correct data size */ + * to curl_off_t since we must be sure to use the correct data size */ curl_easy_setopt(curl, CURLOPT_INFILESIZE, buffer->size); - + /* send all data to this function */ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, buffer_write_callback); /* we pass our mapcache_buffer struct to the callback function */ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)response); - /* Now run off and do what you've been told! */ + /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); - /* Check for errors */ + /* Check for errors */ if(res != CURLE_OK) { ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest put: %s",curl_easy_strerror(res)); } else { @@ -154,18 +154,18 @@ static int _head_request(mapcache_context *ctx, char *url, apr_table_t *headers) } _set_headers(ctx, curl, headers); - + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); /* specify target URL, and note that this URL should include a file - * name, not only a directory */ + * name, not only a directory */ curl_easy_setopt(curl, CURLOPT_URL, url); - + curl_easy_setopt(curl, CURLOPT_NOBODY, 1); - /* Now run off and do what you've been told! */ + /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); - /* Check for errors */ + /* Check for errors */ if(res != CURLE_OK) { ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest head %s",curl_easy_strerror(res)); http_code = 500; @@ -173,9 +173,9 @@ static int _head_request(mapcache_context *ctx, char *url, apr_table_t *headers) curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code); } - /* always cleanup */ + /* always cleanup */ curl_easy_cleanup(curl); - + return (int)http_code; } @@ -196,14 +196,14 @@ static int _delete_request(mapcache_context *ctx, char *url, apr_table_t *header curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); /* specify target URL, and note that this URL should include a file - * name, not only a directory */ + * name, not only a directory */ curl_easy_setopt(curl, CURLOPT_URL, url); - + curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE"); - /* Now run off and do what you've been told! */ + /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); - /* Check for errors */ + /* Check for errors */ if(res != CURLE_OK) { ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest head %s",curl_easy_strerror(res)); http_code = 500; @@ -211,9 +211,9 @@ static int _delete_request(mapcache_context *ctx, char *url, apr_table_t *header curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code); } - /* always cleanup */ + /* always cleanup */ curl_easy_cleanup(curl); - + return (int)http_code; } @@ -243,18 +243,18 @@ static mapcache_buffer* _get_request(mapcache_context *ctx, char *url, apr_table curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)data); /* specify target URL, and note that this URL should include a file - * name, not only a directory */ + * name, not only a directory */ curl_easy_setopt(curl, CURLOPT_URL, url); - /* Now run off and do what you've been told! */ + /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); - /* Check for errors */ + /* Check for errors */ if(res != CURLE_OK) { ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest get: %s",curl_easy_strerror(res)); data = NULL; } else { curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code); - /* handle special behavior of s3 */ + /* handle special behavior of s3 */ if(http_code == 403) { char *msg = data->buf; while(msg && *msg) { @@ -277,9 +277,9 @@ static mapcache_buffer* _get_request(mapcache_context *ctx, char *url, apr_table } } - /* always cleanup */ + /* always cleanup */ curl_easy_cleanup(curl); - + return data; } @@ -287,19 +287,21 @@ apr_table_t* _mapcache_cache_rest_headers(mapcache_context *ctx, mapcache_tile * mapcache_rest_operation *operation) { apr_table_t *ret = apr_table_make(ctx->pool,3); const apr_array_header_t *array; - + if(config->common_headers) { + apr_table_entry_t *elts; + int i; array = apr_table_elts(config->common_headers); - apr_table_entry_t *elts = (apr_table_entry_t *) array->elts; - int i; + elts = (apr_table_entry_t *) array->elts; for (i = 0; i < array->nelts; i++) { apr_table_set(ret, elts[i].key,elts[i].val); } } if(operation->headers) { - array = apr_table_elts(operation->headers); - apr_table_entry_t *elts = (apr_table_entry_t *) array->elts; + apr_table_entry_t *elts; int i; + array = apr_table_elts(operation->headers); + elts = (apr_table_entry_t *) array->elts; for (i = 0; i < array->nelts; i++) { apr_table_set(ret, elts[i].key,elts[i].val); } @@ -459,13 +461,16 @@ static void _mapcache_cache_google_headers_add(mapcache_context *ctx, const char const char *head; const apr_array_header_t *ahead; apr_table_entry_t *elts; - int i,nCanonicalHeaders=0,cnt=0; - assert(rcache->provider == MAPCACHE_REST_PROVIDER_GOOGLE); - mapcache_cache_google *google = (mapcache_cache_google*)rcache; - time_t now = time(NULL); - struct tm *tnow = gmtime(&now); + mapcache_cache_google *google; + time_t now; + struct tm *tnow; unsigned char sha[65]; char b64[150]; + int i,nCanonicalHeaders=0,cnt=0; + assert(rcache->provider == MAPCACHE_REST_PROVIDER_GOOGLE); + google = (mapcache_cache_google*)rcache; + now = time(NULL); + tnow = gmtime(&now); sha[64]=0; strftime(x_amz_date, 64 , "%a, %d %b %Y %H:%M:%S GMT", tnow); @@ -483,7 +488,7 @@ static void _mapcache_cache_google_headers_add(mapcache_context *ctx, const char stringToSign=apr_pstrcat(ctx->pool, method, "\n", head, "\n", NULL); head = apr_table_get(headers, "Content-Type"); if(!head) head = ""; stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL); - + /* Date: header, left empty as we are using x-amz-date */ stringToSign=apr_pstrcat(ctx->pool, stringToSign, "\n", NULL); @@ -506,7 +511,7 @@ static void _mapcache_cache_google_headers_add(mapcache_context *ctx, const char for(i=0; i<nCanonicalHeaders; i++) { stringToSign = apr_pstrcat(ctx->pool, stringToSign, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL); } - + /* find occurence of third "/" in url */ while(*resource) { if(*resource == '/') cnt++; @@ -533,13 +538,16 @@ static void _mapcache_cache_azure_headers_add(mapcache_context *ctx, const char* const char *head; const apr_array_header_t *ahead; apr_table_entry_t *elts; - int i,nCanonicalHeaders=0,cnt=0; - assert(rcache->provider == MAPCACHE_REST_PROVIDER_AZURE); - mapcache_cache_azure *azure = (mapcache_cache_azure*)rcache; - time_t now = time(NULL); - struct tm *tnow = gmtime(&now); + mapcache_cache_azure *azure; + time_t now; + struct tm *tnow; unsigned char sha[65]; char *b64sign,*keyub64; + int i,nCanonicalHeaders=0,cnt=0; + assert(rcache->provider == MAPCACHE_REST_PROVIDER_AZURE); + azure = (mapcache_cache_azure*)rcache; + now = time(NULL); + tnow = gmtime(&now); sha[64]=0; strftime(x_ms_date, sizeof(x_ms_date), "%a, %d %b %Y %H:%M:%S GMT", tnow); @@ -576,8 +584,9 @@ static void _mapcache_cache_azure_headers_add(mapcache_context *ctx, const char* elts = (apr_table_entry_t *) ahead->elts; for (i = 0; i < ahead->nelts; i++) { + char *k; if(strncmp(elts[i].key,"x-ms-",5) || elts[i].key[5]==0) continue; - char *k = aheaders[nCanonicalHeaders] = apr_pstrdup(ctx->pool, elts[i].key); + k = aheaders[nCanonicalHeaders] = apr_pstrdup(ctx->pool, elts[i].key); while(*k) { *k = tolower(*k); k++; @@ -589,7 +598,7 @@ static void _mapcache_cache_azure_headers_add(mapcache_context *ctx, const char* for(i=0; i<nCanonicalHeaders; i++) { canonical_headers = apr_pstrcat(ctx->pool, canonical_headers, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL); } - + /* find occurence of third "/" in url */ while(*resource) { if(*resource == '/') cnt++; @@ -616,7 +625,7 @@ static void _mapcache_cache_azure_headers_add(mapcache_context *ctx, const char* apr_table_set( headers, "Authorization", apr_pstrcat(ctx->pool,"SharedKey ", azure->id, ":", b64sign, NULL)); - + } static void _mapcache_cache_s3_headers_add(mapcache_context *ctx, const char* method, mapcache_cache_rest *rcache, mapcache_tile *tile, char *url, apr_table_t *headers) { @@ -627,15 +636,16 @@ static void _mapcache_cache_s3_headers_add(mapcache_context *ctx, const char* me const apr_array_header_t *ahead; char *tosign, *key, *canonical_request, x_amz_date[64], *resource = url, **aheaders, *auth; apr_table_entry_t *elts; + mapcache_cache_s3 *s3; sha1[64]=sha2[64]=0; assert(rcache->provider == MAPCACHE_REST_PROVIDER_S3); - mapcache_cache_s3 *s3 = (mapcache_cache_s3*)rcache; + s3 = (mapcache_cache_s3*)rcache; if(!strcmp(method,"PUT")) { assert(tile->encoded_data); sha256((unsigned char*)tile->encoded_data->buf, tile->encoded_data->size, sha1); - sha_hex_encode(sha1,32); + sha_hex_encode(sha1,32); } else { /* sha256 hash of empty string */ memcpy(sha1,"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",64); @@ -653,7 +663,7 @@ static void _mapcache_cache_s3_headers_add(mapcache_context *ctx, const char* me ctx->set_error(ctx,500,"invalid s3 url provided"); return; } - + strftime(x_amz_date, sizeof(x_amz_date), "%Y%m%dT%H%M%SZ", tnow); apr_table_set(headers, "x-amz-date", x_amz_date); @@ -670,7 +680,7 @@ static void _mapcache_cache_s3_headers_add(mapcache_context *ctx, const char* me k++; } } - + header_gnome_sort(aheaders, ahead->nelts); for(i=0; i<ahead->nelts; i++) { canonical_request = apr_pstrcat(ctx->pool, canonical_request, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL); @@ -768,7 +778,7 @@ static int _mapcache_cache_rest_has_tile(mapcache_context *ctx, mapcache_cache * if(rcache->rest.has_tile.add_headers) { rcache->rest.has_tile.add_headers(ctx,rcache,tile,url,headers); } - + status = _head_request(ctx, url, headers); if(GC_HAS_ERROR(ctx)) @@ -794,7 +804,7 @@ static void _mapcache_cache_rest_delete(mapcache_context *ctx, mapcache_cache *p if(rcache->rest.delete_tile.add_headers) { rcache->rest.delete_tile.add_headers(ctx,rcache,tile,url,headers); } - + status = _delete_request(ctx, url, headers); GC_CHECK_ERROR(ctx); @@ -851,9 +861,10 @@ static void _mapcache_cache_rest_multi_set(mapcache_context *ctx, mapcache_cache } for(i=0; i<ntiles; i++) { + mapcache_tile *tile; if(i) curl_easy_reset(curl); - mapcache_tile *tile = tiles + i; + tile = tiles + i; _mapcache_cache_rest_tile_url(ctx, tile, &rcache->rest, &rcache->rest.set_tile, &url); headers = _mapcache_cache_rest_headers(ctx, tile, &rcache->rest, &rcache->rest.set_tile); @@ -889,7 +900,7 @@ static void _mapcache_cache_rest_multi_set(mapcache_context *ctx, mapcache_cache } multi_put_cleanup: - /* always cleanup */ + /* always cleanup */ curl_easy_cleanup(curl); } @@ -969,7 +980,7 @@ static void _mapcache_cache_rest_configuration_parse_xml(mapcache_context *ctx, } -static void _mapcache_cache_google_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) +static void _mapcache_cache_google_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) { ezxml_t cur_node; mapcache_cache_google *google = (mapcache_cache_google*)cache; @@ -989,7 +1000,7 @@ static void _mapcache_cache_google_configuration_parse_xml(mapcache_context *ctx } } -static void _mapcache_cache_s3_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) +static void _mapcache_cache_s3_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) { ezxml_t cur_node; mapcache_cache_s3 *s3 = (mapcache_cache_s3*)cache; @@ -1015,7 +1026,7 @@ static void _mapcache_cache_s3_configuration_parse_xml(mapcache_context *ctx, ez } } -static void _mapcache_cache_azure_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) +static void _mapcache_cache_azure_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) { ezxml_t cur_node; mapcache_cache_azure *azure = (mapcache_cache_azure*)cache; diff --git a/lib/cache_riak.c b/lib/cache_riak.c index fba4e24..4c79862 100644 --- a/lib/cache_riak.c +++ b/lib/cache_riak.c @@ -49,7 +49,7 @@ struct riak_conn_params { mapcache_cache_riak *cache; }; -void mapcache_riak_connection_constructor(mapcache_context *ctx, void **conn_, void *params, apr_pool_t *pool) { +void mapcache_riak_connection_constructor(mapcache_context *ctx, void **conn_, void *params) { mapcache_cache_riak *cache = ((struct riak_conn_params*)params)->cache; struct RIACK_CONNECTION_OPTIONS options; struct RIACK_CLIENT *client = riack_new_client(0); @@ -76,7 +76,7 @@ void mapcache_riak_connection_constructor(mapcache_context *ctx, void **conn_, v *conn_ = client; } -void mapcache_riak_connection_destructor(void *conn_, apr_pool_t *process_pool) { +void mapcache_riak_connection_destructor(void *conn_) { struct RIACK_CLIENT *client = (struct RIACK_CLIENT *)conn_; riack_free(client); } @@ -280,7 +280,7 @@ static int _mapcache_cache_riak_get(mapcache_context *ctx, mapcache_cache *pcach * \sa mapcache_cache::tile_set() */ static void _mapcache_cache_riak_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) { - char *key; + char *key,*content_type; int error; int connect_error = RIACK_SUCCESS; int retries = 3; @@ -311,6 +311,16 @@ static void _mapcache_cache_riak_set(mapcache_context *ctx, mapcache_cache *pcac tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format); GC_CHECK_ERROR(ctx); } + content_type = tile->tileset->format?(tile->tileset->format->mime_type?tile->tileset->format->mime_type:NULL):NULL; + + if(!content_type) { + /* compute the content-type */ + mapcache_image_format_type t = mapcache_imageio_header_sniff(ctx,tile->encoded_data); + if(t == GC_PNG) + content_type = "image/png"; + else if(t == GC_JPEG) + content_type = "image/jpeg"; + } pc = _riak_get_connection(ctx, cache, tile); GC_CHECK_ERROR(ctx); @@ -324,8 +334,8 @@ static void _mapcache_cache_riak_set(mapcache_context *ctx, mapcache_cache *pcac object.vclock.len = 0; object.content_count = 1; object.content = &content; - content.content_type.value = tile->tileset->format->mime_type; - content.content_type.len = strlen(tile->tileset->format->mime_type); + content.content_type.value = content_type; + content.content_type.len = content_type?strlen(content_type):0; content.data = (uint8_t*)tile->encoded_data->buf; content.data_len = tile->encoded_data->size; diff --git a/lib/cache_sqlite.c b/lib/cache_sqlite.c index b4dd8dc..d05ae06 100644 --- a/lib/cache_sqlite.c +++ b/lib/cache_sqlite.c @@ -106,7 +106,7 @@ static void mapcache_sqlite_release_conn(mapcache_context *ctx, mapcache_pooled_ mapcache_connection_pool_release_connection(ctx,conn); } -void mapcache_sqlite_connection_constructor(mapcache_context *ctx, void **conn_, void *params, apr_pool_t *process_pool) +void mapcache_sqlite_connection_constructor(mapcache_context *ctx, void **conn_, void *params) { int ret; int flags; @@ -117,6 +117,8 @@ void mapcache_sqlite_connection_constructor(mapcache_context *ctx, void **conn_, flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX; } else { flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_CREATE; + mapcache_make_parent_dirs(ctx,sq_params->dbfile); + GC_CHECK_ERROR(ctx); } ret = sqlite3_open_v2(sq_params->dbfile, &conn->handle, flags, NULL); if (ret != SQLITE_OK) { @@ -144,7 +146,7 @@ void mapcache_sqlite_connection_constructor(mapcache_context *ctx, void **conn_, conn->nstatements = sq_params->cache->n_prepared_statements; } -void mapcache_sqlite_connection_destructor(void *conn_, apr_pool_t *process_pool) +void mapcache_sqlite_connection_destructor(void *conn_) { struct sqlite_conn *conn = (struct sqlite_conn*) conn_; int i; diff --git a/lib/cache_tiff.c b/lib/cache_tiff.c index cc5bfe0..827e7b1 100644 --- a/lib/cache_tiff.c +++ b/lib/cache_tiff.c @@ -437,7 +437,7 @@ static int _mapcache_cache_tiff_get(mapcache_context *ctx, mapcache_cache *pcach memcpy(tile->encoded_data->buf,jpegtable_ptr,(jpegtable_size-2)); /* advance the data pointer to after the header data */ - bufptr = tile->encoded_data->buf + (jpegtable_size-2); + bufptr = ((char *)tile->encoded_data->buf) + (jpegtable_size-2); /* go to the specified offset in the tiff file, plus 2 bytes */ @@ -512,10 +512,8 @@ static void _mapcache_cache_tiff_set(mapcache_context *ctx, mapcache_cache *pcac int rv; void *lock; int create; - char errmsg[120]; mapcache_cache_tiff *cache; mapcache_image_format_jpeg *format; - char *hackptr1,*hackptr2; int tilew; int tileh; unsigned char *rgb; @@ -541,27 +539,8 @@ static void _mapcache_cache_tiff_set(mapcache_context *ctx, mapcache_cache *pcac /* * create the directory where the tiff file will be stored */ - - /* find the location of the last '/' in the string */ - hackptr2 = hackptr1 = filename; - while(*hackptr1) { - if(*hackptr1 == '/') - hackptr2 = hackptr1; - hackptr1++; - } - *hackptr2 = '\0'; - - if(APR_SUCCESS != (rv = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) { - /* - * apr_dir_make_recursive sometimes sends back this error, although it should not. - * ignore this one - */ - if(!APR_STATUS_IS_EEXIST(rv)) { - ctx->set_error(ctx, 500, "failed to create directory %s: %s",filename, apr_strerror(rv,errmsg,120)); - return; - } - } - *hackptr2 = '/'; + mapcache_make_parent_dirs(ctx,filename); + GC_CHECK_ERROR(ctx); tilew = tile->grid_link->grid->tile_sx; tileh = tile->grid_link->grid->tile_sy; @@ -833,7 +812,7 @@ static void _mapcache_cache_tiff_configuration_parse_xml(mapcache_context *ctx, if(cur_node) { mapcache_config_parse_locker(ctx, cur_node, &cache->locker); } - + } /** diff --git a/lib/connection_pool.c b/lib/connection_pool.c index 1999d8e..3bf3901 100644 --- a/lib/connection_pool.c +++ b/lib/connection_pool.c @@ -64,7 +64,7 @@ static apr_status_t mapcache_connection_container_destructor(void *conn_, void * mapcache_pooled_connection *pc = pcc->head; while(pc) { mapcache_pooled_connection *this = pc; - this->private->destructor(this->connection, pcc->pool); + this->private->destructor(this->connection); free(this->private->key); pc = this->private->next; free(this); @@ -73,6 +73,7 @@ static apr_status_t mapcache_connection_container_destructor(void *conn_, void * return MAPCACHE_SUCCESS; } + apr_status_t mapcache_connection_pool_create(mapcache_connection_pool **cp, apr_pool_t *server_pool) { apr_status_t rv; *cp = apr_pcalloc(server_pool, sizeof(mapcache_connection_pool)); @@ -126,7 +127,7 @@ mapcache_pooled_connection* mapcache_connection_pool_get_connection(mapcache_con /* ctx->log(ctx, MAPCACHE_DEBUG, "calling constructor for pooled connection (%s)", key); */ - constructor(ctx, &pc->connection, params, pcc->pool); + constructor(ctx, &pc->connection, params); if(GC_HAS_ERROR(ctx)) { free(pc); apr_reslist_release(ctx->connection_pool->connexions, pcc); @@ -150,7 +151,7 @@ mapcache_pooled_connection* mapcache_connection_pool_get_connection(mapcache_con count++; } ctx->log(ctx, MAPCACHE_DEBUG, "tearing down pooled connection (%s) to make room", opc->private->key); - opc->private->destructor(opc->connection, pcc->pool); + opc->private->destructor(opc->connection); free(opc->private->key); free(opc->private); free(opc); @@ -172,7 +173,7 @@ void mapcache_connection_pool_invalidate_connection(mapcache_context *ctx, mapca } else { pcc->head = pc->private->next; } - pc->private->destructor(pc->connection, pcc->pool); + pc->private->destructor(pc->connection); free(pc->private->key); free(pc); } diff --git a/lib/core.c b/lib/core.c index de2befd..63f4244 100644 --- a/lib/core.c +++ b/lib/core.c @@ -196,10 +196,13 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r { int expires = 0; mapcache_http_response *response; - int i,is_empty=1; /* response image is initially empty */; char *timestr; - mapcache_image *base=NULL; - mapcache_image_format *format = NULL; + mapcache_image *base; + mapcache_image_format *format; + mapcache_image_format_type t; + int i,is_empty=1; /* response image is initially empty */; + base=NULL; + format = NULL; #ifdef DEBUG if(req_tile->ntiles ==0) { @@ -208,7 +211,7 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r } #endif response = mapcache_http_response_create(ctx->pool); - + if(ctx->supports_redirects && req_tile->ntiles == 1) { req_tile->tiles[0]->allow_redirect = 1; } @@ -233,7 +236,7 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r if(tile->expires && (tile->expires < expires || expires == 0)) { expires = tile->expires; } - + if(tile->nodata) { /* treat the special case where the cache explicitely stated that the tile was empty, and we don't have any vertical merging to do */ @@ -244,8 +247,8 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r } continue; } - - /* treat the most common case: + + /* treat the most common case: - we have a single tile request (i.e. isempty is true) - the cache returned the encoded image */ @@ -282,7 +285,7 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r mapcache_image_merge(ctx, base, tile->raw_image); } else { /* we don't need to merge onto an existing tile and don't have access to the tile's encoded data. - * + * * we don't encode the tile's raw image data just yet because we might need to merge another one on top * of it later. */ @@ -307,20 +310,20 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r return NULL; } } else { + unsigned char empty[5] = {'#',0,0,0,0}; #ifdef DEBUG if(!is_empty) { ctx->set_error(ctx,500,"BUG: no image data to encode, but tile not marked as empty"); return NULL; } #endif - unsigned char empty[5] = {'#',0,0,0,0}; response->data = mapcache_empty_png_decode(ctx,req_tile->tiles[0]->grid_link->grid->tile_sx, req_tile->tiles[0]->grid_link->grid->tile_sy, empty,&is_empty); /* is_empty is unchanged and left to 1 */ format = mapcache_configuration_get_image_format(ctx->config,"PNG8"); } } - + /* compute the content-type */ - mapcache_image_format_type t = mapcache_imageio_header_sniff(ctx,response->data); + t = mapcache_imageio_header_sniff(ctx,response->data); if(t == GC_PNG) apr_table_set(response->headers,"Content-Type","image/png"); else if(t == GC_JPEG) @@ -345,12 +348,13 @@ mapcache_map* mapcache_assemble_maps(mapcache_context *ctx, mapcache_map **maps, mapcache_tile ***maptiles; int *nmaptiles; mapcache_tile **tiles; + mapcache_grid_link **effectively_used_grid_links; mapcache_map *basemap = NULL; int ntiles = 0; int i; maptiles = apr_pcalloc(ctx->pool,nmaps*sizeof(mapcache_tile**)); nmaptiles = apr_pcalloc(ctx->pool,nmaps*sizeof(int)); - mapcache_grid_link **effectively_used_grid_links = apr_pcalloc(ctx->pool,nmaps*sizeof(mapcache_grid_link*)); + effectively_used_grid_links = apr_pcalloc(ctx->pool,nmaps*sizeof(mapcache_grid_link*)); for(i=0; i<nmaps; i++) { mapcache_tileset_get_map_tiles(ctx,maps[i]->tileset,maps[i]->grid_link, &maps[i]->extent, maps[i]->width, maps[i]->height, diff --git a/lib/dimension.c b/lib/dimension.c index 037aab3..cde7db6 100644 --- a/lib/dimension.c +++ b/lib/dimension.c @@ -38,7 +38,24 @@ #include <float.h> #endif +#ifndef HAVE_TIMEGM +time_t timegm(struct tm *tm) +{ + time_t t, tdiff; + struct tm in, gtime, ltime; + + memcpy(&in, tm, sizeof(in)); + t = mktime(&in); + + memcpy(>ime, gmtime(&t), sizeof(gtime)); + memcpy(<ime, localtime(&t), sizeof(ltime)); + gtime.tm_isdst = ltime.tm_isdst; + tdiff = t - mktime(>ime); + memcpy(&in, tm, sizeof(in)); + return mktime(&in) + tdiff; +} +#endif static int _mapcache_dimension_intervals_validate(mapcache_context *ctx, mapcache_dimension *dim, char **value) { @@ -307,16 +324,16 @@ struct sqlite_dimension_conn { int n_statements; }; -void mapcache_sqlite_dimension_connection_constructor(mapcache_context *ctx, void **conn_, void *params, apr_pool_t *pool) +void mapcache_sqlite_dimension_connection_constructor(mapcache_context *ctx, void **conn_, void *params) { int ret; - int flags; + int flags; char *dbfile = (char*) params; struct sqlite_dimension_conn *conn = calloc(1, sizeof (struct sqlite_dimension_conn)); *conn_ = conn; flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX; ret = sqlite3_open_v2(dbfile, &conn->handle, flags, NULL); - + if (ret != SQLITE_OK) { ctx->set_error(ctx,500,"failed to open sqlite dimension dbfile (%s): %s",dbfile,sqlite3_errmsg(conn->handle)); sqlite3_close(conn->handle); @@ -326,7 +343,7 @@ void mapcache_sqlite_dimension_connection_constructor(mapcache_context *ctx, voi sqlite3_busy_timeout(conn->handle, 300000); } -void mapcache_sqlite_dimension_connection_destructor(void *conn_, apr_pool_t *pool) +void mapcache_sqlite_dimension_connection_destructor(void *conn_) { struct sqlite_dimension_conn *conn = (struct sqlite_dimension_conn*) conn_; while(conn->n_statements) { @@ -385,7 +402,7 @@ static int _mapcache_dimension_sqlite_validate(mapcache_context *ctx, mapcache_d goto cleanup; } } - + paramidx = sqlite3_bind_parameter_index(conn->prepared_statements[0], ":dim"); if (paramidx) { sqliteret = sqlite3_bind_text(conn->prepared_statements[0], paramidx, *value, -1, SQLITE_STATIC); @@ -414,7 +431,7 @@ cleanup: sqlite3_reset(conn->prepared_statements[0]); } _sqlite_dimension_release_conn(ctx,pc); - + return ret; } @@ -434,7 +451,7 @@ static apr_array_header_t* _mapcache_dimension_sqlite_print(mapcache_context *ct conn->prepared_statements = calloc(2,sizeof(sqlite3_stmt*)); conn->n_statements = 2; } - + if(!conn->prepared_statements[1]) { sqliteret = sqlite3_prepare_v2(conn->handle, dimension->list_query, -1, &conn->prepared_statements[1], NULL); if(sqliteret != SQLITE_OK) { @@ -459,7 +476,7 @@ cleanup: sqlite3_reset(conn->prepared_statements[1]); } _sqlite_dimension_release_conn(ctx,pc); - + return ret; } @@ -469,7 +486,7 @@ static void _mapcache_dimension_sqlite_parse_xml(mapcache_context *ctx, mapcache { mapcache_dimension_sqlite *dimension; ezxml_t child; - + dimension = (mapcache_dimension_sqlite*)dim; child = ezxml_child(node,"dbfile"); @@ -493,7 +510,7 @@ static void _mapcache_dimension_sqlite_parse_xml(mapcache_context *ctx, mapcache ctx->set_error(ctx,400,"sqlite dimension \"%s\" has no <list_query> node", dim->name); return; } - + } @@ -554,7 +571,7 @@ static void _bind_sqlite_timedimension_params(mapcache_context *ctx, sqlite3_stm return; } } - + paramidx = sqlite3_bind_parameter_index(stmt, ":start_timestamp"); if (paramidx) { ret = sqlite3_bind_int64(stmt, paramidx, start); @@ -598,13 +615,13 @@ apr_array_header_t *_mapcache_timedimension_sqlite_get_entries(mapcache_context return NULL; } } - + _bind_sqlite_timedimension_params(ctx,conn->prepared_statements[0],conn->handle,tileset,grid,extent,start,end); if(GC_HAS_ERROR(ctx)) { _sqlite_dimension_release_conn(ctx, pc); return NULL; } - + time_ids = apr_array_make(ctx->pool,0,sizeof(char*)); do { ret = sqlite3_step(conn->prepared_statements[0]); @@ -643,7 +660,7 @@ typedef enum { void _mapcache_timedimension_sqlite_parse_xml(mapcache_context *ctx, mapcache_timedimension *dim, ezxml_t node) { mapcache_timedimension_sqlite *sdim = (mapcache_timedimension_sqlite*)dim; ezxml_t child; - + child = ezxml_child(node,"dbfile"); if(child && child->txt && *child->txt) { sdim->dbfile = apr_pstrdup(ctx->pool,child->txt); @@ -662,8 +679,8 @@ void _mapcache_timedimension_sqlite_parse_xml(mapcache_context *ctx, mapcache_ti #endif char *mapcache_ogc_strptime(const char *value, struct tm *ts, mapcache_time_interval_t *ti) { - memset (ts, '\0', sizeof (*ts)); char *valueptr; + memset (ts, '\0', sizeof (*ts)); valueptr = strptime(value,"%Y-%m-%dT%H:%M:%SZ",ts); *ti = MAPCACHE_TINTERVAL_SECOND; if(valueptr) return valueptr; @@ -700,7 +717,7 @@ apr_array_header_t* mapcache_timedimension_get_entries_for_value(mapcache_contex ctx->set_error(ctx,400,"failed to parse time %s",value); return NULL; } - + if(*valueptr == '/' || (*valueptr == '-' && *(valueptr+1) == '-')) { /* we have a second (end) time */ if (*valueptr == '/') { diff --git a/lib/ezxml.c b/lib/ezxml.c index dd9470f..2b1558e 100644 --- a/lib/ezxml.c +++ b/lib/ezxml.c @@ -370,7 +370,7 @@ short ezxml_internal_dtd(ezxml_root_t root, char *s, size_t len) else *s = '\0'; // null terminate tag name for (i = 0; root->attr[i] && strcmp(n, root->attr[i][0]); i++); - while (*(n = ++s + strspn(s, EZXML_WS)) && *n != '>') { + while (*(n = s + 1 + strspn(s + 1, EZXML_WS)) && *n != '>') { if (*(s = n + strcspn(n, EZXML_WS))) *s = '\0'; // attr name else { ezxml_err(root, t, "malformed <!ATTLIST"); diff --git a/lib/http.c b/lib/http.c index dd24965..e4aad04 100644 --- a/lib/http.c +++ b/lib/http.c @@ -105,6 +105,7 @@ void mapcache_http_do_request(mapcache_context *ctx, mapcache_http *req, mapcach char error_msg[CURL_ERROR_SIZE]; int ret; struct curl_slist *curl_headers=NULL; + struct _header_struct h; curl_handle = curl_easy_init(); @@ -121,7 +122,6 @@ void mapcache_http_do_request(mapcache_context *ctx, mapcache_http *req, mapcach if(headers != NULL) { /* intercept headers */ - struct _header_struct h; h.headers = headers; h.ctx=ctx; curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, _mapcache_curl_header_callback); @@ -142,7 +142,7 @@ void mapcache_http_do_request(mapcache_context *ctx, mapcache_http *req, mapcach int i; for (i = 0; i < array->nelts; i++) { char *val = elts[i].val; - if(strchr(val,'{') && ctx->headers_in) { + if(val && strchr(val,'{') && ctx->headers_in) { _header_replace_str(ctx,ctx->headers_in,&val); } curl_headers = curl_slist_append(curl_headers, apr_pstrcat(ctx->pool,elts[i].key,": ",val,NULL)); diff --git a/lib/image.c b/lib/image.c index 4d228b5..4dd11d1 100644 --- a/lib/image.c +++ b/lib/image.c @@ -85,6 +85,9 @@ int mapcache_image_has_alpha(mapcache_image *img) void mapcache_image_merge(mapcache_context *ctx, mapcache_image *base, mapcache_image *overlay) { int starti,startj; + pixman_image_t *si; + pixman_image_t *bi; + pixman_transform_t transform; #ifndef USE_PIXMAN int i,j; unsigned char *browptr, *orowptr, *bptr, *optr; @@ -97,11 +100,10 @@ void mapcache_image_merge(mapcache_context *ctx, mapcache_image *base, mapcache_ starti = (base->h - overlay->h)/2; startj = (base->w - overlay->w)/2; #ifdef USE_PIXMAN - pixman_image_t *si = pixman_image_create_bits(PIXMAN_a8r8g8b8,overlay->w,overlay->h, + si = pixman_image_create_bits(PIXMAN_a8r8g8b8,overlay->w,overlay->h, (uint32_t*)overlay->data,overlay->stride); - pixman_image_t *bi = pixman_image_create_bits(PIXMAN_a8r8g8b8,base->w,base->h, + bi = pixman_image_create_bits(PIXMAN_a8r8g8b8,base->w,base->h, (uint32_t*)base->data,base->stride); - pixman_transform_t transform; pixman_transform_init_translate(&transform, pixman_int_to_fixed(-startj), pixman_int_to_fixed(-starti)); diff --git a/lib/imageio_png.c b/lib/imageio_png.c index 2b5de6d..fbd32a5 100644 --- a/lib/imageio_png.c +++ b/lib/imageio_png.c @@ -324,14 +324,10 @@ void _mapcache_imageio_png_flush_func(png_structp png_ptr) // do nothing } -#ifndef _WIN32 -static inline int premultiply (int color,int alpha) -#else -static __inline int premultiply (int color,int alpha) -#endif -{ - int temp = (alpha * color) + 0x80; - return ((temp + (temp >> 8)) >> 8); +#define PREMULTIPLY(out,color,alpha)\ +{\ + int temp = ((alpha) * (color)) + 0x80;\ + out =((temp + (temp >> 8)) >> 8);\ } @@ -425,9 +421,9 @@ void _mapcache_imageio_png_decode_to_image(mapcache_context *ctx, mapcache_buffe pixptr[1] = 0; pixptr[2] = 0; } else { - pixptr[0] = premultiply(pixel[2],alpha); - pixptr[1] = premultiply(pixel[1],alpha); - pixptr[2] = premultiply(pixel[0],alpha); + PREMULTIPLY(pixptr[0],pixel[2],alpha); + PREMULTIPLY(pixptr[1],pixel[1],alpha); + PREMULTIPLY(pixptr[2],pixel[0],alpha); } pixptr += 4; } diff --git a/lib/lock.c b/lib/lock.c index 2cef016..3275d50 100644 --- a/lib/lock.c +++ b/lib/lock.c @@ -31,7 +31,9 @@ #include <apr_file_io.h> #include <apr_strings.h> #include <apr_time.h> +#ifndef _WIN32 #include <unistd.h> +#endif #define MAPCACHE_LOCKFILE_PREFIX "_gc_lock" @@ -60,7 +62,7 @@ int mapcache_lock_or_wait_for_resource(mapcache_context *ctx, mapcache_locker *l else { apr_time_t start_wait = apr_time_now(); rv = MAPCACHE_LOCK_LOCKED; - + while(rv != MAPCACHE_LOCK_NOENT) { unsigned int waited = apr_time_as_msec(apr_time_now()-start_wait); if(waited > locker->timeout*1000) { @@ -81,7 +83,7 @@ mapcache_lock_result mapcache_locker_disk_aquire_lock(mapcache_context *ctx, map mapcache_locker_disk *ldisk; apr_file_t *lockfile; apr_status_t rv; - + assert(self->type == MAPCACHE_LOCKER_DISK); ldisk = (mapcache_locker_disk*)self; *lock = NULL; /*unused*/ @@ -188,6 +190,11 @@ mapcache_lock_result mapcache_locker_fallback_aquire_lock(mapcache_context *ctx, fallback_lock->locker = child_locker; ctx->push_errors(ctx,error); return lock_result; + } else { + /*clear the current error if we still have a fallback lock to try */ + if(i<locker->lockers->nelts-1) { + ctx->clear_errors(ctx); + } } ctx->push_errors(ctx,error); } @@ -245,7 +252,7 @@ static char* memcache_key_for_resource(mapcache_context *ctx, mapcache_locker_me char *saferes = apr_pstrdup(ctx->pool,resource); char *safeptr = saferes; while(*safeptr) { - if(*safeptr==' ' || *safeptr == '/' || *safeptr == '~' || *safeptr == '.' || + if(*safeptr==' ' || *safeptr == '/' || *safeptr == '~' || *safeptr == '.' || *safeptr == '\r' || *safeptr == '\n' || *safeptr == '\t' || *safeptr == '\f' || *safeptr == '\e' || *safeptr == '\a' || *safeptr == '\b') { *safeptr = '#'; } @@ -287,7 +294,7 @@ mapcache_lock_result mapcache_locker_memcache_ping_lock(mapcache_context *ctx, m size_t ione; mapcache_locker_memcache *lm = (mapcache_locker_memcache*)self; char *key = memcache_key_for_resource(ctx, lm, resource); - apr_memcache_t *memcache = (apr_memcache_t*)lock; + apr_memcache_t *memcache = (apr_memcache_t*)lock; if(!memcache) return MAPCACHE_LOCK_NOENT; rv = apr_memcache_getp(memcache,ctx->pool,key,&one,&ione,NULL); @@ -296,14 +303,14 @@ mapcache_lock_result mapcache_locker_memcache_ping_lock(mapcache_context *ctx, m else return MAPCACHE_LOCK_NOENT; } - + mapcache_lock_result mapcache_locker_memcache_aquire_lock(mapcache_context *ctx, mapcache_locker *self, char *resource, void **lock) { apr_status_t rv; mapcache_locker_memcache *lm = (mapcache_locker_memcache*)self; char errmsg[120]; char *key = memcache_key_for_resource(ctx, lm, resource); - apr_memcache_t *memcache = create_memcache(ctx,lm); + apr_memcache_t *memcache = create_memcache(ctx,lm); if(GC_HAS_ERROR(ctx)) { return MAPCACHE_LOCK_NOENT; } @@ -324,12 +331,12 @@ void mapcache_locker_memcache_release_lock(mapcache_context *ctx, mapcache_locke mapcache_locker_memcache *lm = (mapcache_locker_memcache*)self; char errmsg[120]; char *key = memcache_key_for_resource(ctx, lm, resource); - apr_memcache_t *memcache = (apr_memcache_t*)lock; + apr_memcache_t *memcache = (apr_memcache_t*)lock; if(!memcache) { /*error*/ return; } - + rv = apr_memcache_delete(memcache,key,0); if(rv != APR_SUCCESS && rv!= APR_NOTFOUND) { ctx->set_error(ctx,500,"memcache: failed to delete key %s: %s", key, apr_strerror(rv,errmsg,120)); @@ -383,7 +390,7 @@ void mapcache_config_parse_locker(mapcache_context *ctx, ezxml_t node, mapcache_ return; } (*locker)->parse_xml(ctx, *locker, node); - + if((cur_node = ezxml_child(node,"retry")) != NULL) { char *endptr; (*locker)->retry_interval = strtod(cur_node->txt,&endptr); diff --git a/lib/service_demo.c b/lib/service_demo.c index 716b26c..c6512a5 100644 --- a/lib/service_demo.c +++ b/lib/service_demo.c @@ -553,10 +553,13 @@ void _create_demo_wms(mapcache_context *ctx, mapcache_request_get_capabilities * apr_array_header_t *timedimvals = tileset->timedimension->get_all_entries( ctx,tileset->timedimension,tileset); for(id=0;id<timedimvals->nelts;id++) { + char *idval; + char *dimparam_wms; + char *dimparam_singletile; if(id>1) break; - char *idval = APR_ARRAY_IDX(timedimvals,id,char*); - char *dimparam_wms = " %s_wms_layer.mergeNewParams({%s:\"%s\"});\n"; - char *dimparam_singletile = " %s_slayer.mergeNewParams({%s:\"%s\"});\n"; + idval = APR_ARRAY_IDX(timedimvals,id,char*); + dimparam_wms = " %s_wms_layer.mergeNewParams({%s:\"%s\"});\n"; + dimparam_singletile = " %s_slayer.mergeNewParams({%s:\"%s\"});\n"; ol_layer_name = apr_psprintf(ctx->pool, "%s_%s_%s", tileset->name, grid->name, idval); /* normalize name to something that is a valid variable name */ for(i=0; i<strlen(ol_layer_name); i++) @@ -581,7 +584,7 @@ void _create_demo_wms(mapcache_context *ctx, mapcache_request_get_capabilities * caps = apr_psprintf(ctx->pool,"%s%s",caps,ol_layer); caps = apr_psprintf(ctx->pool,"%s%s",caps, apr_psprintf(ctx->pool,dimparam_wms,ol_layer_name,tileset->timedimension->key,idval)); - + if(service->getmap_strategy == MAPCACHE_GETMAP_ASSEMBLE) { ol_layer = apr_psprintf(ctx->pool, demo_layer_singletile, ol_layer_name, @@ -660,15 +663,11 @@ void _create_demo_mapguide(mapcache_context *ctx, mapcache_request_get_capabilit tileindex_index = apr_hash_first(ctx->pool,ctx->config->tilesets); while(tileindex_index) { int i,j; - char *extension; mapcache_tileset *tileset; const void *key; apr_ssize_t keylen; apr_hash_this(tileindex_index,&key,&keylen,(void**)&tileset); - extension = "png"; - if (tileset->format && tileset->format->extension) - extension = tileset->format->extension; for(j=0; j<tileset->grid_links->nelts; j++) { char *resolutions=""; char *unit="dd"; @@ -873,9 +872,11 @@ void _create_demo_wmts(mapcache_context *ctx, mapcache_request_get_capabilities ctx,tileset->timedimension,tileset); GC_CHECK_ERROR(ctx); for(id=0;id<timedimvals->nelts;id++) { + char *idval; + char *dimparam; if(id>1) break; /* we don't want all the entries in the demo interface */ - char *idval = APR_ARRAY_IDX(timedimvals,id,char*); - char *dimparam = "%s_wmts_layer.mergeNewParams({%s:\"%s\"});\n"; + idval = APR_ARRAY_IDX(timedimvals,id,char*); + dimparam = "%s_wmts_layer.mergeNewParams({%s:\"%s\"});\n"; ol_layer_name = apr_psprintf(ctx->pool, "%s_%s_%s", tileset->name, grid->name, idval); /* normalize name to something that is a valid variable name */ for(i=0; i<strlen(ol_layer_name); i++) @@ -903,7 +904,7 @@ void _create_demo_wmts(mapcache_context *ctx, mapcache_request_get_capabilities caps = apr_psprintf(ctx->pool,"%s%s",caps,ol_layer); caps = apr_psprintf(ctx->pool,"%s%s",caps, apr_psprintf(ctx->pool,dimparam,ol_layer_name,tileset->timedimension->key,idval)); - + } } } diff --git a/lib/service_wms.c b/lib/service_wms.c index 1fc643e..6e6c34f 100644 --- a/lib/service_wms.c +++ b/lib/service_wms.c @@ -200,7 +200,7 @@ void _create_capabilities_wms(mapcache_context *ctx, mapcache_request_get_capabi layerxml = ezxml_add_child(toplayer,"Layer",0); ezxml_set_attr(layerxml, "cascaded", "1"); ezxml_set_attr(layerxml, "queryable", (tileset->source && tileset->source->info_formats)?"1":"0"); - + ezxml_set_txt(ezxml_add_child(layerxml,"Name",0),tileset->name); tsxml = ezxml_add_child(vendorxml, "TileSet",0); @@ -715,9 +715,9 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service /* we need to create more tile/map entries */ if(timedim_selected->nelts > 1) { /* apr pools have no realloc */ + mapcache_tile** tmptiles; nallocated = nallocated + timedim_selected->nelts - 1; - mapcache_tile** tmptiles = - apr_palloc(ctx->pool, nallocated * sizeof(mapcache_tile*)); + tmptiles = apr_palloc(ctx->pool, nallocated * sizeof(mapcache_tile*)); for(i=0;i<tile_req->ntiles;i++) { tmptiles[i] = tile_req->tiles[i]; } @@ -738,9 +738,9 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service /* we need to create more tile/map entries */ if(timedim_selected->nelts > 1) { /* apr pools have no realloc */ + mapcache_map** tmpmaps; nallocated = nallocated + timedim_selected->nelts - 1; - mapcache_map** tmpmaps = - apr_palloc(ctx->pool, nallocated * sizeof(mapcache_map*)); + tmpmaps = apr_palloc(ctx->pool, nallocated * sizeof(mapcache_map*)); for(i=0;i<map_req->nmaps;i++) { tmpmaps[i] = map_req->maps[i]; } @@ -756,7 +756,7 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service apr_table_set(map_req->maps[map_req->nmaps-1]->dimensions,tileset->timedimension->key, APR_ARRAY_IDX(timedim_selected,i,char*)); } - + } } } @@ -965,7 +965,7 @@ void _configuration_parse_wms_xml(mapcache_context *ctx, ezxml_t node, mapcache_ rule = apr_pcalloc(ctx->pool, sizeof(mapcache_forwarding_rule)); rule->name = apr_pstrdup(ctx->pool,name); rule->match_params = apr_array_make(ctx->pool,1,sizeof(mapcache_dimension*)); - rule->max_post_len = 10485760; /* 10 megabytes by default */ + rule->max_post_len = 10485760; /* 10 megabytes by default */ node = ezxml_child(rule_node,"append_pathinfo"); if(node && !strcasecmp(node->txt,"true")) { @@ -973,7 +973,7 @@ void _configuration_parse_wms_xml(mapcache_context *ctx, ezxml_t node, mapcache_ } else { rule->append_pathinfo = 0; } - + node = ezxml_child(rule_node,"max_post_length"); if(node) { char *endptr; @@ -983,7 +983,7 @@ void _configuration_parse_wms_xml(mapcache_context *ctx, ezxml_t node, mapcache_ return; } } - + node = ezxml_child(rule_node,"http"); if(!node) { ctx->set_error(ctx,500,"rule \"%s\" does not contain an <http> block",name); diff --git a/lib/service_wmts.c b/lib/service_wmts.c index 541f9fb..569bbc7 100644 --- a/lib/service_wmts.c +++ b/lib/service_wmts.c @@ -414,16 +414,17 @@ void _create_capabilities_wmts(mapcache_context *ctx, mapcache_request_get_capab int j; for(j=0; j<grid_link->grid->nlevels; j++) { ezxml_t matrixlimits = ezxml_add_child(limits,"TileMatrixLimits",0); + int row; ezxml_set_txt(ezxml_add_child(matrixlimits,"TileMatrix",0), apr_psprintf(ctx->pool,"%s:%d",grid_link->grid->name,j)); ezxml_set_txt(ezxml_add_child(matrixlimits,"MinTileRow",0), - apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].minx)); + apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].miny)); ezxml_set_txt(ezxml_add_child(matrixlimits,"MaxTileRow",0), - apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].maxx-1)); + apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].maxy-1)); ezxml_set_txt(ezxml_add_child(matrixlimits,"MinTileCol",0), - apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].miny)); + apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].minx)); ezxml_set_txt(ezxml_add_child(matrixlimits,"MaxTileCol",0), - apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].maxy-1)); + apr_psprintf(ctx->pool,"%d",grid_link->grid_limits[j].maxx-1)); } } diff --git a/lib/strptime.c b/lib/strptime.c index ff52ef1..992d1cb 100644 --- a/lib/strptime.c +++ b/lib/strptime.c @@ -40,7 +40,6 @@ #include <time.h> #include "util.h" - static const char *abb_weekdays[] = { "Sun", "Mon", diff --git a/lib/tileset.c b/lib/tileset.c index 8677d48..df81b75 100644 --- a/lib/tileset.c +++ b/lib/tileset.c @@ -406,7 +406,7 @@ mapcache_metatile* mapcache_tileset_metatile_get(mapcache_context *ctx, mapcache /* configured metatile size in geographical units */ fullgwidth = res * tileset->metasize_x * grid->tile_sx; fullgheight = res * tileset->metasize_y * grid->tile_sy; - + switch(grid->origin) { case MAPCACHE_GRID_ORIGIN_BOTTOM_LEFT: mt->map.extent.minx = grid->extent.minx + mt->x * fullgwidth - gbuffer; @@ -618,20 +618,21 @@ mapcache_feature_info* mapcache_tileset_feature_info_create(apr_pool_t *pool, ma } void mapcache_tileset_assemble_out_of_zoom_tile(mapcache_context *ctx, mapcache_tile *tile) { - assert(tile->grid_link->outofzoom_strategy == MAPCACHE_OUTOFZOOM_REASSEMBLE); - - /* we have at most 4 tiles composing the requested tile */ mapcache_extent tile_bbox; double shrink_x, shrink_y, scalefactor; int x[4],y[4]; int i, n=1; + mapcache_tile *childtile; + assert(tile->grid_link->outofzoom_strategy == MAPCACHE_OUTOFZOOM_REASSEMBLE); + + /* we have at most 4 tiles composing the requested tile */ mapcache_grid_get_extent(ctx,tile->grid_link->grid,tile->x,tile->y,tile->z, &tile_bbox); /* shrink the extent so we do not fall exactly on a tile boundary, to avoid rounding errors when computing the x,y of the lower level tile(s) we will need */ - + shrink_x = (tile_bbox.maxx - tile_bbox.minx) / (tile->grid_link->grid->tile_sx * 1000); /* 1/1000th of a pixel */ shrink_y = (tile_bbox.maxy - tile_bbox.miny) / (tile->grid_link->grid->tile_sy * 1000); /* 1/1000th of a pixel */ tile_bbox.maxx -= shrink_x; @@ -656,15 +657,15 @@ void mapcache_tileset_assemble_out_of_zoom_tile(mapcache_context *ctx, mapcache_ tile_bbox.minx -= shrink_x; tile_bbox.miny -= shrink_y; - mapcache_tile *childtile = mapcache_tileset_tile_clone(ctx->pool,tile); + childtile = mapcache_tileset_tile_clone(ctx->pool,tile); childtile->z = tile->grid_link->max_cached_zoom; scalefactor = childtile->grid_link->grid->levels[childtile->z]->resolution/tile->grid_link->grid->levels[tile->z]->resolution; tile->nodata = 1; for(i=0;i<n;i++) { - childtile->x = x[i]; - childtile->y = y[i]; mapcache_extent childtile_bbox; double dstminx,dstminy; + childtile->x = x[i]; + childtile->y = y[i]; mapcache_tileset_tile_get(ctx,childtile); GC_CHECK_ERROR(ctx); if(childtile->nodata) { @@ -700,13 +701,14 @@ void mapcache_tileset_assemble_out_of_zoom_tile(mapcache_context *ctx, mapcache_ * https://bugs.freedesktop.org/show_bug.cgi?id=46277 */ unsigned int row,col; unsigned char *srcpixptr; + unsigned char *row_ptr; unsigned int dstminxi = - dstminx / scalefactor; unsigned int dstminyi = - dstminy / scalefactor; srcpixptr = &(childtile->raw_image->data[dstminyi * childtile->raw_image->stride + dstminxi * 4]); /* ctx->log(ctx, MAPCACHE_WARN, "factor: %g. pixel: %d,%d (val:%d)",scalefactor,dstminxi,dstminyi,*((unsigned int*)srcpixptr)); */ - unsigned char *row_ptr = tile->raw_image->data; + row_ptr = tile->raw_image->data; for(row=0;row<tile->raw_image->h;row++) { unsigned char *pix_ptr = row_ptr; for(col=0;col<tile->raw_image->w;col++) { @@ -726,8 +728,8 @@ void mapcache_tileset_assemble_out_of_zoom_tile(mapcache_context *ctx, mapcache_ - - + + } void mapcache_tileset_outofzoom_get(mapcache_context *ctx, mapcache_tile *tile) { @@ -803,14 +805,14 @@ void mapcache_tileset_tile_get(mapcache_context *ctx, mapcache_tile *tile) return; } } - - + + if (ret == MAPCACHE_CACHE_MISS || ret == MAPCACHE_CACHE_RELOAD) { int isLocked; void *lock; /* If the tile does not exist or stale, we must take action before re-asking for it */ - if( !tile->tileset->read_only && tile->tileset->source && !ctx->config->non_blocking) { + if( !tile->tileset->read_only && tile->tileset->source && !ctx->config->non_blocking) { /* * is the tile already being rendered by another thread ? * the call is protected by the same mutex that sets the lock on the tile, @@ -846,16 +848,16 @@ void mapcache_tileset_tile_get(mapcache_context *ctx, mapcache_tile *tile) } } - if (ret == MAPCACHE_CACHE_RELOAD && GC_HAS_ERROR(ctx)) - /* If we tried to reload a stale tile but failed, we know we have already - * fetched it from the cache. We can then ignore errors and just use old tile. + if (ret == MAPCACHE_CACHE_RELOAD && GC_HAS_ERROR(ctx)) + /* If we tried to reload a stale tile but failed, we know we have already + * fetched it from the cache. We can then ignore errors and just use old tile. */ ctx->clear_errors(ctx); else { - /* Else, check for errors and try to fetch the tile from the cache. - */ - GC_CHECK_ERROR(ctx); + /* Else, check for errors and try to fetch the tile from the cache. + */ + GC_CHECK_ERROR(ctx); ret = tile->tileset->_cache->tile_get(ctx, tile->tileset->_cache, tile); GC_CHECK_ERROR(ctx); diff --git a/lib/util.c b/lib/util.c index 590532a..fe9e1cb 100644 --- a/lib/util.c +++ b/lib/util.c @@ -33,6 +33,7 @@ #include <apr_tables.h> #include <curl/curl.h> #include <math.h> +#include <apr_file_io.h> #ifndef _WIN32 #include <unistd.h> @@ -41,6 +42,14 @@ #ifndef M_PI #define M_PI 3.14159265358979323846264338327 #endif + +#ifdef _WIN32 +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long int uint64_t; +#endif + const double mapcache_meters_per_unit[MAPCACHE_UNITS_COUNT] = {1.0,6378137.0 * 2.0 * M_PI / 360,0.3048}; @@ -65,11 +74,15 @@ char *base64_encode(apr_pool_t *pool, const unsigned char *data, size_t input_le for (i = 0, j = 0; i < input_length;) { - uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0; - uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0; - uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0; + uint32_t octet_a; + uint32_t octet_b; + uint32_t octet_c; + uint32_t triple; + octet_a = i < input_length ? (unsigned char)data[i++] : 0; + octet_b = i < input_length ? (unsigned char)data[i++] : 0; + octet_c = i < input_length ? (unsigned char)data[i++] : 0; - uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c; + triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c; encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F]; encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F]; @@ -79,7 +92,7 @@ char *base64_encode(apr_pool_t *pool, const unsigned char *data, size_t input_le for (i = 0; i < mod_table[input_length % 3]; i++) encoded_data[output_length - 2 - i] = '='; - + encoded_data[output_length-1]=0; return encoded_data; @@ -261,10 +274,11 @@ void _mapcache_context_pop_errors(mapcache_context *ctx, void **error) void _mapcache_context_push_errors(mapcache_context *ctx, void *error) { struct _error_log *e = (struct _error_log*)error; - ctx->_errcode = e->_errcode; + if(e->_errcode) + ctx->_errcode = e->_errcode; if(e->_errmsg) { if(ctx->_errmsg) { - ctx->_errmsg = apr_psprintf(ctx->pool,"%s\n%s",ctx->_errmsg,e->_errmsg); + ctx->_errmsg = apr_psprintf(ctx->pool,"%s\n%s",e->_errmsg,ctx->_errmsg); } else { ctx->_errmsg = e->_errmsg; } @@ -387,9 +401,41 @@ char* mapcache_util_get_tile_key(mapcache_context *ctx, mapcache_tile *tile, cha return path; } +void mapcache_make_parent_dirs(mapcache_context *ctx, char *filename) { + char *hackptr1,*hackptr2=NULL; + apr_status_t ret; + char errmsg[120]; + + /* find the location of the last '/' in the string */ + hackptr1 = filename; + while(*hackptr1) { + if(*hackptr1 == '/') + hackptr2 = hackptr1; + hackptr1++; + } + + if(hackptr2) { + /* terminate string on last '/' */ + *hackptr2 = '\0'; + } -/* vim: ts=2 sts=2 et sw=2 -*/ + ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool); + + if(hackptr2) { + *hackptr2 = '/'; + } + + + if(APR_SUCCESS != ret) { + /* + * apr_dir_make_recursive sometimes sends back this error, although it should not. + * ignore this one + */ + if(!APR_STATUS_IS_EEXIST(ret)) { + ctx->set_error(ctx, 500, "failed to create directory %s: %s",filename, apr_strerror(ret,errmsg,120)); + } + } +} #if defined(_WIN32) && !defined(__CYGWIN__) @@ -443,3 +489,8 @@ void mapcache_gettimeofday(struct mctimeval* tp, void* tzp) #endif + +/* vim: ts=2 sts=2 et sw=2 +*/ + + diff --git a/release.sh b/release.sh new file mode 100755 index 0000000..1966ac3 --- /dev/null +++ b/release.sh @@ -0,0 +1,54 @@ +#!/bin/bash + +ms_version=$1 + +echo "release steps for mapcache version $ms_version (mapcache-$ms_version.tar.gz)" +echo "" + +ms_version_suffix=`echo $ms_version | cut -s -d- -f2` +if [ -z $ms_version_suffix ]; then + ms_version_num=$ms_version +else + ms_version_num=`echo $ms_version | cut -s -d- -f1` +fi + +ms_version_major=`echo $ms_version_num | cut -d. -f1` +ms_version_minor=`echo $ms_version_num | cut -d. -f2` +ms_version_revision=`echo $ms_version_num | cut -d. -f3` + + +tagname=rel-$ms_version_major-$ms_version_minor-$ms_version_revision +if [ ! -z $ms_version_suffix ]; then + tagname=$tagname-$ms_version_suffix +fi + +echo "#" +echo "# make sure:" +echo "# - you are on branch-$ms_version_major-$ms_version_minor" +echo "# - you have edited HISTORY.TXT with changes related to this release" +echo "#" +echo "" + +echo "sed -i '/set (MAPCACHE_VERSION_MAJOR/c\set (MAPCACHE_VERSION_MAJOR $ms_version_major)' CMakeLists.txt" +echo "sed -i '/set (MAPCACHE_VERSION_MINOR/c\set (MAPCACHE_VERSION_MINOR $ms_version_minor)' CMakeLists.txt" +echo "sed -i '/set (MAPCACHE_VERSION_REVISION/c\set (MAPCACHE_VERSION_REVISION $ms_version_revision)' CMakeLists.txt" +if [ ! -z $ms_version_suffix ]; then + echo "sed -i '/set (MAPCACHE_VERSION_SUFFIX/c\set (MAPCACHE_VERSION_SUFFIX \"-$ms_version_suffix\")' CMakeLists.txt" +else + echo "sed -i '/set (MAPCACHE_VERSION_SUFFIX/c\set (MAPCACHE_VERSION_SUFFIX \"\")' CMakeLists.txt" +fi + +echo "git add CMakeLists.txt" +echo "git commit -m \"update for $ms_version release\"" +echo "git tag -a $tagname -m \"Create $ms_version tag\"" +echo "git push origin branch-$ms_version_major-$ms_version_minor --tags" +echo "git archive --format=tar.gz --prefix=mapcache-$ms_version/ $tagname >/tmp/mapcache-$ms_version.tar.gz" +echo "scp /tmp/mapcache-$ms_version.tar.gz download.osgeo.org:/osgeo/download/mapserver" + +echo "" +echo "#" +echo "#optionally update doc site, these commands need tweaking before being ran" +echo "#" + +echo "/path/to/docs/scripts/changelog.sh rel-previous-tag..$tagname >> /path/to/docs/en/development/changelog/changelog-$ms_version_major-$ms_version_minor.txt" + diff --git a/util/mapcache_seed.c b/util/mapcache_seed.c index f483122..56ac570 100644 --- a/util/mapcache_seed.c +++ b/util/mapcache_seed.c @@ -37,6 +37,7 @@ #include <time.h> #ifndef _WIN32 #include <unistd.h> +#include <sys/stat.h> #define USE_FORK #include <sys/time.h> #endif @@ -136,6 +137,7 @@ cmd mode = MAPCACHE_CMD_SEED; /* the mode the utility will be running in: either int push_queue(struct seed_cmd cmd) { + struct seed_cmd *pcmd; #ifdef USE_FORK if(nprocesses > 1) { struct msg_cmd mcmd; @@ -148,7 +150,7 @@ int push_queue(struct seed_cmd cmd) return APR_SUCCESS; } #endif - struct seed_cmd *pcmd = calloc(1,sizeof(struct seed_cmd)); + pcmd = calloc(1,sizeof(struct seed_cmd)); *pcmd = cmd; return apr_queue_push(work_queue,pcmd); } @@ -169,7 +171,7 @@ int pop_queue(struct seed_cmd *cmd) return APR_SUCCESS; } #endif - + ret = apr_queue_pop(work_queue, (void**)&pcmd); if(ret == APR_SUCCESS) { *cmd = *pcmd; @@ -280,6 +282,10 @@ int ogr_features_intersect_tile(mapcache_context *ctx, mapcache_tile *tile) { mapcache_metatile *mt = mapcache_tileset_metatile_get(ctx,tile); GEOSCoordSequence *mtbboxls = GEOSCoordSeq_create(5,2); + GEOSGeometry *mtbbox = GEOSGeom_createLinearRing(mtbboxls); + GEOSGeometry *mtbboxg = GEOSGeom_createPolygon(mtbbox,NULL,0); + int i; + int intersects = 0; GEOSCoordSeq_setX(mtbboxls,0,mt->map.extent.minx); GEOSCoordSeq_setY(mtbboxls,0,mt->map.extent.miny); GEOSCoordSeq_setX(mtbboxls,1,mt->map.extent.maxx); @@ -290,10 +296,6 @@ int ogr_features_intersect_tile(mapcache_context *ctx, mapcache_tile *tile) GEOSCoordSeq_setY(mtbboxls,3,mt->map.extent.maxy); GEOSCoordSeq_setX(mtbboxls,4,mt->map.extent.minx); GEOSCoordSeq_setY(mtbboxls,4,mt->map.extent.miny); - GEOSGeometry *mtbbox = GEOSGeom_createLinearRing(mtbboxls); - GEOSGeometry *mtbboxg = GEOSGeom_createPolygon(mtbbox,NULL,0); - int i; - int intersects = 0; for(i=0; i<nClippers; i++) { const GEOSPreparedGeometry *clipper = clippers[i]; if(GEOSPreparedIntersects(clipper,mtbboxg)) { @@ -310,8 +312,15 @@ int ogr_features_intersect_tile(mapcache_context *ctx, mapcache_tile *tile) cmd examine_tile(mapcache_context *ctx, mapcache_tile *tile) { int action = MAPCACHE_CMD_SKIP; - int intersects = -1; - int tile_exists = force?0:tileset->_cache->tile_exists(ctx,tileset->_cache,tile); + int tile_exists; + +#ifdef USE_CLIPPERS + /* check we are in the requested features before checking the tile */ + if(nClippers > 0 && ogr_features_intersect_tile(ctx,tile) == 0) + return MAPCACHE_CMD_SKIP; +#endif + + tile_exists = force?0:tileset->_cache->tile_exists(ctx,tileset->_cache,tile); /* if the tile exists and a time limit was specified, check the tile modification date */ if(tile_exists) { @@ -319,32 +328,20 @@ cmd examine_tile(mapcache_context *ctx, mapcache_tile *tile) if(tileset->_cache->tile_get(ctx,tileset->_cache, tile) == MAPCACHE_SUCCESS) { if(tile->mtime && tile->mtime<age_limit) { /* the tile modification time is older than the specified limit */ -#ifdef USE_CLIPPERS - /* check we are in the requested features before deleting the tile */ - if(nClippers > 0) { - intersects = ogr_features_intersect_tile(ctx,tile); - } -#endif - if(intersects != 0) { - /* the tile intersects the ogr features, or there was no clipping asked for: seed it */ - if(mode == MAPCACHE_CMD_SEED || mode == MAPCACHE_CMD_TRANSFER) { - mapcache_tileset_tile_delete(ctx,tile,MAPCACHE_TRUE); - /* if we are in mode transfer, delete it from the dst tileset */ - if (mode == MAPCACHE_CMD_TRANSFER) { - tile->tileset = tileset_transfer; - if (tile->tileset->_cache->tile_exists(ctx,tile->tileset->_cache, tile)) { - mapcache_tileset_tile_delete(ctx,tile,MAPCACHE_TRUE); - } - tile->tileset = tileset; - } - action = mode; - } else { //if(action == MAPCACHE_CMD_DELETE) - action = MAPCACHE_CMD_DELETE; - } - } else { - /* the tile does not intersect the ogr features, and already exists, do nothing */ - action = MAPCACHE_CMD_SKIP; + if(mode == MAPCACHE_CMD_SEED || mode == MAPCACHE_CMD_TRANSFER) { + mapcache_tileset_tile_delete(ctx,tile,MAPCACHE_TRUE); + /* if we are in mode transfer, delete it from the dst tileset */ + if (mode == MAPCACHE_CMD_TRANSFER) { + tile->tileset = tileset_transfer; + if (tile->tileset->_cache->tile_exists(ctx,tile->tileset->_cache, tile)) { + mapcache_tileset_tile_delete(ctx,tile,MAPCACHE_TRUE); } + tile->tileset = tileset; + } + action = mode; + } else { //if(action == MAPCACHE_CMD_DELETE) + action = MAPCACHE_CMD_DELETE; + } } } else { //BUG: tile_exists returned true, but tile_get returned a failure. not sure what to do. @@ -372,20 +369,7 @@ cmd examine_tile(mapcache_context *ctx, mapcache_tile *tile) } else { // the tile does not exist if(mode == MAPCACHE_CMD_SEED || mode == MAPCACHE_CMD_TRANSFER) { -#ifdef USE_CLIPPERS - /* check we are in the requested features before deleting the tile */ - if(nClippers > 0) { - if(ogr_features_intersect_tile(ctx,tile)) { - action = mode; - } else { - action = MAPCACHE_CMD_SKIP; - } - } else { - action = mode; - } -#else action = mode; -#endif } else { action = MAPCACHE_CMD_SKIP; } @@ -605,14 +589,17 @@ void seed_worker() mapcache_metatile *mt = mapcache_tileset_metatile_get(&seed_ctx, tile); for (i = 0; i < mt->ntiles; i++) { mapcache_tile *subtile = &mt->tiles[i]; - mapcache_tileset_tile_get(&seed_ctx, subtile); - subtile->tileset = tileset_transfer; - subtile->tileset->_cache->tile_set(&seed_ctx, subtile->tileset->_cache, subtile); + int cache_ret; + cache_ret = tileset->_cache->tile_get(&seed_ctx, tileset->_cache, subtile); + if(cache_ret == MAPCACHE_SUCCESS && !GC_HAS_ERROR(&seed_ctx)) { + subtile->tileset = tileset_transfer; + subtile->tileset->_cache->tile_set(&seed_ctx, subtile->tileset->_cache, subtile); + } } } else { //CMD_DELETE mapcache_tileset_tile_delete(&seed_ctx,tile,MAPCACHE_TRUE); } - + { struct seed_status *st = calloc(1,sizeof(struct seed_status)); st->x=tile->x; @@ -647,10 +634,17 @@ static void* APR_THREAD_FUNC seed_thread(apr_thread_t *thread, void *data) { } static void* APR_THREAD_FUNC log_thread_fn(apr_thread_t *thread, void *data) { + size_t cur; + double last_time; + double now_time; + int i; + int nfailed; + int ntotal; + double pct; char failed[FAIL_BACKLOG_COUNT]; memset(failed,-1,FAIL_BACKLOG_COUNT); - size_t cur=0; - double last_time=0, now_time; + cur=0; + last_time=0; while(1) { struct seed_status *st; apr_status_t ret = apr_queue_pop(log_queue, (void**)&st); @@ -674,16 +668,17 @@ static void* APR_THREAD_FUNC log_thread_fn(apr_thread_t *thread, void *data) { } else { /* count how many errors and successes we have */ failed[cur]=1; - int i,nfailed=0,ntotal=0; + nfailed=0; + ntotal=0; if(failed_log) { fprintf(failed_log,"%d,%d,%d\n",st->x,st->y,st->z); } for(i=0; i<FAIL_BACKLOG_COUNT; i++) { if(failed[i]>=0) ntotal++; - if(failed[i]==1) nfailed++; + if(failed[i]==1) nfailed++; } ctx.log(&ctx, MAPCACHE_WARN, "failed to seed tile z%d,x%d,y%d:\n%s\n", st->z,st->x,st->y,st->msg); - double pct = ((double)nfailed / (double)ntotal) * 100; + pct = ((double)nfailed / (double)ntotal) * 100; if(pct > percent_failed_allowed) { ctx.log(&ctx, MAPCACHE_ERROR, "aborting seed as %.1f%% of the last %d requests failed\n", pct, FAIL_BACKLOG_COUNT); error_detected = 1; @@ -783,6 +778,8 @@ int main(int argc, const char **argv) double *extent_array = NULL; #ifdef USE_CLIPPERS + OGRFeatureH hFeature; + GEOSWKTReader *geoswktreader; const char *ogr_where = NULL; const char *ogr_layer = NULL; const char *ogr_sql = NULL; @@ -976,6 +973,7 @@ int main(int argc, const char **argv) } if(ogr_datasource) { + int f=0; OGRDataSourceH hDS = NULL; OGRLayerH layer = NULL; OGRRegisterAll(); @@ -1023,21 +1021,20 @@ int main(int argc, const char **argv) clippers = (const GEOSPreparedGeometry**)malloc(nClippers*sizeof(GEOSPreparedGeometry*)); - OGRFeatureH hFeature; - GEOSWKTReader *geoswktreader = GEOSWKTReader_create(); + geoswktreader = GEOSWKTReader_create(); OGR_L_ResetReading(layer); - extent = apr_palloc(ctx.pool,4*sizeof(mapcache_extent)); - int f=0; + extent = apr_palloc(ctx.pool,sizeof(mapcache_extent)); while( (hFeature = OGR_L_GetNextFeature(layer)) != NULL ) { + char *wkt; + GEOSGeometry *geosgeom; + OGREnvelope ogr_extent; OGRGeometryH geom = OGR_F_GetGeometryRef(hFeature); if(!geom || !OGR_G_IsValid(geom)) continue; - char *wkt; OGR_G_ExportToWkt(geom,&wkt); - GEOSGeometry *geosgeom = GEOSWKTReader_read(geoswktreader,wkt); + geosgeom = GEOSWKTReader_read(geoswktreader,wkt); free(wkt); clippers[f] = GEOSPrepare(geosgeom); //GEOSGeom_destroy(geosgeom); - OGREnvelope ogr_extent; OGR_G_GetEnvelope (geom, &ogr_extent); if(f == 0) { extent->minx = ogr_extent.MinX; @@ -1086,6 +1083,38 @@ int main(int argc, const char **argv) return usage(argv[0],"grid not configured for tileset"); } } +#ifdef USE_CLIPPERS + if(ogr_datasource) { + /* check that the provided ogr features are compatible with the grid units */ + if(grid_link->grid->unit == MAPCACHE_UNIT_DEGREES) { + if(extent->minx < -181.0 || + extent->maxx > 181.0 || + extent->miny < -91.0 || + extent->maxy > 91.0) { + printf("\n********************************************************************************\n" + "* WARNING!!!: you are seeding a grid in latlon degreees,\n" + "* but your provided OGR intersection features span (%f,%f,%f,%f).\n" + "* this seems like an error, you should be providing OGR features that\n" + "* are in the same projection as the grid you want to seed\n" + "********************************************************************************\n\n", + extent->minx, extent->miny, extent->maxx, extent->maxy); + } + } else { + if(extent->minx > -181.0 && + extent->maxx < 181.0 && + extent->miny > -91.0 && + extent->maxy < 91.0) { + printf("\n********************************************************************************\n" + "* WARNING!!!: you are seeding a grid that is not in latlon degreees,\n" + "* but your provided OGR intersection features span (%f,%f,%f,%f) which seem to be in degrees.\n" + "* this seems like an error, you should be providing OGR features that\n" + "* are in the same projection as the grid you want to seed\n" + "********************************************************************************\n\n", + extent->minx, extent->miny, extent->maxx, extent->maxy); + } + } + } +#endif if(iteration_mode == MAPCACHE_ITERATION_UNSET) { if(!strcmp(grid_link->grid->name,"g") || !strcmp(grid_link->grid->name,"WGS84") || !strcmp(grid_link->grid->name,"GoogleMapsCompatible")) { @@ -1222,11 +1251,11 @@ int main(int argc, const char **argv) apr_table_set(dimensions,tileset->timedimension->key,APR_ARRAY_IDX(timedim_selected,0,char*)); } else { return usage(argv[0],"tileset references a TIME dimension, but none supplied on commandline. (hint: -D %s=<timestamp>",tileset->timedimension->key); - + } } } - + { /* start the logging thread */ //create the queue where the seeding statuses will be put @@ -1334,9 +1363,9 @@ int main(int argc, const char **argv) apr_terminate(); if (error_detected > 0) { - exit(1); + exit(1); } - + return 0; } /* vim: ts=2 sts=2 et sw=2 -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/mapcache.git _______________________________________________ Pkg-grass-devel mailing list [email protected] http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-grass-devel
