pax_global_header 0000666 0000000 0000000 00000000064 14653160677 0014531 g ustar 00root root 0000000 0000000 52 comment=6d31ab83c86162bf77b8a1bead57d177cda1c2ea
mapcache-rel-1-14-1/ 0000775 0000000 0000000 00000000000 14653160677 0014134 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/.github/ 0000775 0000000 0000000 00000000000 14653160677 0015474 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/.github/FUNDING.yml 0000664 0000000 0000000 00000000243 14653160677 0017310 0 ustar 00root root 0000000 0000000 # point to OSGeo sponsor page
github: [OSGeo]
# point to PayPal directly
custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MS7JAL9R268D2 mapcache-rel-1-14-1/.github/workflows/ 0000775 0000000 0000000 00000000000 14653160677 0017531 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/.github/workflows/backport.yml 0000664 0000000 0000000 00000001013 14653160677 0022054 0 ustar 00root root 0000000 0000000 name: Backport
on:
pull_request_target:
types:
- closed
- labeled
jobs:
backport:
runs-on: ubuntu-latest
name: Backport
steps:
- name: Backport Bot
id: backport
if: github.event.pull_request.merged && ( ( github.event.action == 'closed' && contains( join( github.event.pull_request.labels.*.name ), 'backport') ) || contains( github.event.label.name, 'backport' ) )
uses: m-kuhn/backport@v1.2.7
with:
github_token: ${{ secrets.GITHUB_TOKEN }} mapcache-rel-1-14-1/.github/workflows/build-linux.yml 0000664 0000000 0000000 00000005201 14653160677 0022506 0 ustar 00root root 0000000 0000000 name: Build MapCache on Linux
on: [ push, pull_request ]
jobs:
build-matrix:
strategy:
matrix:
os: [ ubuntu-20.04 ]
option: [ minimal, default, maximal ]
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v2
- name: Install dependencies
run: |
if [[ 'minimal,default,maximal' =~ ${{ matrix.option }} ]]
then
sudo apt-get update -y
sudo apt-get upgrade -y
sudo apt-get install -y libcurl4-openssl-dev apache2-dev
fi
if [[ 'default,maximal' =~ ${{ matrix.option }} ]]
then
sudo apt-get install -y libgdal-dev libfcgi-dev libpixman-1-dev
sudo apt-get install -y gdal-bin libxml2-utils
fi
if [[ 'maximal' =~ ${{ matrix.option }} ]]
then
sudo apt-get install -y libhiredis-dev libdb-dev libmapserver-dev libpcre2-dev
fi
- name: Build MapCache
run: |
if [[ 'minimal' == ${{ matrix.option }} ]]
then
options="-DWITH_SQLITE=OFF \
-DWITH_PIXMAN=OFF \
-DWITH_GDAL=OFF \
-DWITH_APACHE=OFF \
-DWITH_CGI=OFF \
-DWITH_OGR=OFF \
-DWITH_GEOS=OFF \
-DWITH_MAPCACHE_DETAIL=OFF"
elif [[ 'default' == ${{ matrix.option }} ]]
then
options=""
elif [[ 'maximal' == ${{ matrix.option }} ]]
then
options="-DWITH_POSTGRESQL=ON \
-DWITH_BERKELEY_DB=ON \
-DWITH_MEMCACHE=ON \
-DWITH_REDIS=ON \
-DWITH_TIFF=ON \
-DWITH_TIFF_WRITE_SUPPORT=ON \
-DWITH_GEOTIFF=ON \
-DWITH_PCRE=OFF \
-DWITH_PCRE2=ON \
-DWITH_MAPSERVER=ON \
-DWITH_RIAK=OFF"
fi
mkdir build
cd build
cmake ${options} ${{ github.workspace }}
make
sudo make install
sudo ldconfig
- name: Run tests
run: |
if [[ 'ubuntu-20.04' == ${{ matrix.os }} ]] \
&& [[ 'default' == ${{ matrix.option }} ]]
then
cd ${{ github.workspace }}/tests
./setup.sh
./run.sh
else
echo No test performed on this target
fi
mapcache-rel-1-14-1/.github/workflows/build-windows.yml 0000664 0000000 0000000 00000013103 14653160677 0023041 0 ustar 00root root 0000000 0000000 name: Build MapCache on Windows
on: [ push, pull_request ]
jobs:
build-matrix:
strategy:
matrix:
os: [ windows-2019 ]
option: [ default ]
runs-on: ${{matrix.os}}
steps:
- name: Checkout repository
uses: actions/checkout@v2
- name: Install dependencies
run: |
Set-Location -Path "${{github.workspace}}"
New-Item -Path . -Name "sdk" -ItemType "directory"
Set-Location -Path "sdk"
curl -O https://download.gisinternals.com/sdk/downloads/release-1928-x64-dev.zip
unzip -qq release-1928-x64-dev.zip
$sdkprefix = "${{github.workspace}}\sdk\release-1928-x64"
Set-Location -Path "$sdkprefix\lib"
Copy-Item -Path "libfcgi.lib" -Destination "fcgi.lib"
Copy-Item -Path "apr-1.lib" -Destination "apr-1-1.lib"
Copy-Item -Path "libapr-1.lib" -Destination "apr-1.lib"
Copy-Item -Path "aprutil-1.lib" -Destination "aprutil-1-1.lib"
Copy-Item -Path "libaprutil-1.lib" -Destination "aprutil-1.lib"
- name: Build MapCache
run: |
$sdkprefix = "${{github.workspace}}\sdk\release-1928-x64"
Set-Location -Path "${{github.workspace}}"
New-Item -Path . -Name "build" -ItemType "directory"
Set-Location -Path "build"
cmake -DCMAKE_PREFIX_PATH="$sdkprefix" -DWITH_APACHE=OFF -DWITH_FCGI=ON -DWITH_PCRE=ON -DWITH_TIFF=OFF "${{github.workspace}}"
cmake --build . --config Release
Copy-Item -Destination "$sdkprefix\bin" -Path "Release\mapcache.dll", "cgi\Release\mapcache.fcgi.exe", "util\Release\mapcache_seed.exe", "contrib\mapcache_detail\Release\mapcache_detail.exe"
Set-Location -Path "$sdkprefix\bin"
Compress-Archive -DestinationPath "${{github.workspace}}\mapcache.zip" -Path "${{github.workspace}}\mapcache.xml", "mapcache.dll", "mapcache.fcgi.exe", "mapcache_seed.exe", "mapcache_detail.exe"
- name: Upload binary artifacts
uses: actions/upload-artifact@v2
with:
name: binaries
path: mapcache.zip
retention-days: 15
- name: Setup tests
run: |
$sdkprefix = "${{github.workspace}}\sdk\release-1928-x64"
Set-Location -Path "${{github.workspace}}\build"
Copy-Item -Path "..\tests\data\world.tif" -Destination .
New-Item -Path "mapcache.xml"
Set-Content -Path "mapcache.xml" -Value @"
${{github.workspace}}\build\world.tif
${{github.workspace}}\build
disk
global-tif
GoogleMapsCompatible
JPEG
1 1
${{github.workspace}}\build
debug
"@
- name: Run tests
run: |
$sdkprefix = "${{github.workspace}}\sdk\release-1928-x64"
Set-Location -Path "$sdkprefix\bin"
$env:GDAL_DATA = "$sdkprefix\bin\gdal-data"
$env:PROJ_LIB = "$sdkprefix\bin\proj9\share"
.\mapcache_seed.exe -c "${{github.workspace}}\build\mapcache.xml" -t global --force -z 0,1
Copy-Item -Path "${{github.workspace}}\build\global\GoogleMapsCompatible\00\000\000\000\000\000\000.jpg" -Destination "${{github.workspace}}\seed.jpg"
.\gdal\apps\gdalinfo.exe -checksum "${{github.workspace}}\seed.jpg"
$match = (.\gdal\apps\gdalinfo.exe -checksum "${{github.workspace}}\seed.jpg" | Select-String -CaseSensitive -Pattern "Checksum=21411" -Quiet)
if ( $match ) {
"Success: matched checksum for seed.jpg"
} else {
"Failure: Did not get expected checksum for seed.jpg"
exit 1
}
$env:MAPCACHE_CONFIG_FILE = "${{github.workspace}}\build\mapcache.xml"
$env:REQUEST_METHOD = "GET"
$env:PATH_INFO = "/wmts/1.0.0/global/default/GoogleMapsCompatible/0/0/0.jpg"
$env:QUERY_STRING = ""
Start-Process -FilePath ".\mapcache.fcgi.exe" -RedirectStandardOutput "${{github.workspace}}\fcgi.jpg" -NoNewWindow -Wait
perl.exe -0777 -pi -e 'binmode ARGV;binmode ARGVOUT;s/[A-Z][a-z][-:; ,\/=A-Za-z0-9\r\n]*//' "${{github.workspace}}\fcgi.jpg"
.\gdal\apps\gdalinfo.exe -checksum "${{github.workspace}}\fcgi.jpg"
$match = (.\gdal\apps\gdalinfo.exe -checksum "${{github.workspace}}\fcgi.jpg" | Select-String -CaseSensitive -Pattern "Checksum=21411" -Quiet)
if ( $match ) {
"Success: matched checksum for fcgi.jpg"
} else {
"Failure: Did not get expected checksum for fcgi.jpg"
exit 1
}
- name: Upload test artifacts
uses: actions/upload-artifact@v2
with:
name: test-results
path: |
seed.jpg
fcgi.jpg
retention-days: 2
mapcache-rel-1-14-1/.github/workflows/check-crlf.yml 0000664 0000000 0000000 00000000754 14653160677 0022263 0 ustar 00root root 0000000 0000000 # check for Windows CRLF in files
# homepage: https://github.com/marketplace/actions/check-crlf
name: Check CRLF
on: [push, pull_request]
jobs:
Check-CRLF:
name: verify that only LF linefeeds are used
runs-on: ubuntu-18.04
steps:
- name: Checkout repository contents
uses: actions/checkout@v1
- name: Use action to check for CRLF endings
uses: erclu/check-crlf@v1.1.2
with: # ignore directories below, space-delimited
exclude: mapcache-rel-1-14-1/.github/workflows/irc_notify.yml 0000664 0000000 0000000 00000002673 14653160677 0022431 0 ustar 00root root 0000000 0000000 # send build notifications to the #mapcache IRC channel
# homepage: https://github.com/marketplace/actions/notify-irc
name: "IRC Push Notification"
on:
push:
branches:
- main
pull_request:
branches:
- main
jobs:
irc_notify:
runs-on: ubuntu-latest
#if: github.repository == 'MapServer/mapcache'
steps:
- name: irc push
uses: rectalogic/notify-irc@v1
if: github.event_name == 'push'
with:
channel: "#mapcache"
server: "irc.libera.chat"
nickname: mapcache-github-notifier
message: |
${{ github.actor }} pushed ${{ github.event.ref }} ${{ github.event.compare }}
${{ join(github.event.commits.*.message) }}
- name: irc pull request
uses: rectalogic/notify-irc@v1
if: github.event_name == 'pull_request'
with:
channel: "#mapcache"
server: "irc.libera.chat"
nickname: mapcache-github-notifier
message: |
${{ github.actor }} opened PR ${{ github.event.pull_request.html_url }}
- name: irc tag created
uses: rectalogic/notify-irc@v1
if: github.event_name == 'create' && github.event.ref_type == 'tag'
with:
channel: "#mapcache"
server: "irc.libera.chat"
nickname: mapcache-github-notifier
message: |
${{ github.actor }} tagged ${{ github.repository }} ${{ github.event.ref }}
mapcache-rel-1-14-1/.gitignore 0000664 0000000 0000000 00000000065 14653160677 0016125 0 ustar 00root root 0000000 0000000 .*.swp
nbproject/
/build/
/build_vagrant/
/.vagrant/
mapcache-rel-1-14-1/CMakeLists.txt 0000664 0000000 0000000 00000031305 14653160677 0016676 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 3.0...3.29)
project (MapCache C)
include(CheckFunctionExists)
include(CheckIncludeFile)
include(CheckCSourceCompiles)
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
add_definitions(-DDEBUG)
endif ()
set (MAPCACHE_VERSION_MAJOR 1)
set (MAPCACHE_VERSION_MINOR 14)
set (MAPCACHE_VERSION_REVISION 1)
if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
set(CMAKE_INSTALL_LIBDIR lib)
endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
if(NOT DEFINED CMAKE_INSTALL_BINDIR)
set(CMAKE_INSTALL_BINDIR bin)
endif(NOT DEFINED CMAKE_INSTALL_BINDIR)
MATH(EXPR MAPCACHE_IS_DEV_VERSION "1-${MAPCACHE_VERSION_MINOR}%2")
if(MAPCACHE_IS_DEV_VERSION)
set (MAPCACHE_VERSION_STRING "${MAPCACHE_VERSION_MAJOR}.${MAPCACHE_VERSION_MINOR}.${MAPCACHE_VERSION_REVISION}")
else(MAPCACHE_IS_DEV_VERSION)
set (MAPCACHE_VERSION_STRING "${MAPCACHE_VERSION_MAJOR}.${MAPCACHE_VERSION_MINOR}dev")
endif(MAPCACHE_IS_DEV_VERSION)
MATH(EXPR MAPCACHE_VERSION_NUM "${MAPCACHE_VERSION_MAJOR}*10000+${MAPCACHE_VERSION_MINOR}*100+${MAPCACHE_VERSION_REVISION}")
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
if (APPLE)
set(CMAKE_FIND_FRAMEWORK "LAST")
endif (APPLE)
macro( report_optional_not_found component )
message(SEND_ERROR "${component} library/component/dependency could not be found.
HINTS:
- disable ${component} support by adding -DWITH_${component}=0
- add the ${component} install directory to the CMAKE_PREFIX_PATH variable (-DCMAKE_PREFIX_PATH=\"/path/to/${component}-install-dir;/path/to/other/dirs\"")
endmacro()
macro( report_mandatory_not_found component )
message(SEND_ERROR "${component} library/component could not be found and is a mandatory dependency
HINT:
- add the ${component} install directory to the CMAKE_PREFIX_PATH variable (-DCMAKE_PREFIX_PATH=\"/path/to/${component}-install-dir;/path/to/other/dirs\"")
endmacro()
macro( report_dependency_error component dependency)
message(SEND_ERROR "${component} support requires ${dependency} support, however ${dependency} support has been disabled.
HINTS:
- re-run with -DWITH_${dependency}=1 (or without -DWITH_${dependency}=0)
- disable ${component} support by adding -DWITH_${component}=0"
)
endmacro()
check_function_exists("strncasecmp" HAVE_STRNCASECMP)
check_function_exists("symlink" HAVE_SYMLINK)
check_function_exists ("timegm" HAVE_TIMEGM)
check_function_exists ("strptime" HAVE_STRPTIME)
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
set(CMAKE_SKIP_BUILD_RPATH FALSE)
if(APPLE)
set(CMAKE_MACOSX_RPATH ON)
endif()
set(CMAKE_LINK_INTERFACE_LIBRARY "")
file(GLOB mapcache_SOURCES lib/*.c )
file(GLOB mapcache_HEADERS include/*.h)
add_library(mapcache SHARED ${mapcache_SOURCES} ${mapcache_HEADERS})
set_target_properties(mapcache PROPERTIES
VERSION ${MAPCACHE_VERSION_STRING}
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 -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/dimension backend" ON)
option(WITH_POSTGRESQL "Use PostgreSQL as a dimension backend" OFF)
option(WITH_BERKELEY_DB "Use Berkeley DB as a cache backend" OFF)
option(WITH_LMDB "Use LMDB as a cache backend" OFF)
option(WITH_MEMCACHE "Use memcache as a cache backend (requires recent apr-util)" OFF)
option(WITH_REDIS "Use redis as a cache backend (requires hiredis library)" OFF)
option(WITH_TIFF "Use TIFFs as a cache backend" OFF)
option(WITH_TIFF_WRITE_SUPPORT "Enable (experimental) support for writable TIFF cache backends" OFF)
option(WITH_GEOTIFF "Allow GeoTIFF metadata creation for TIFF cache backends" OFF)
option(WITH_PCRE "Use PCRE for regex tests" OFF)
option(WITH_PCRE2 "Use PCRE2 for regex tests" OFF)
option(WITH_MAPSERVER "Enable (experimental) support for the mapserver library" OFF)
option(WITH_RIAK "Use Riak as a cache backend" OFF)
option(WITH_GDAL "Choose if GDAL raster support should be built in" ON)
option(WITH_MAPCACHE_DETAIL "Build coverage analysis tool for SQLite caches" ON)
find_package(PNG)
if(PNG_FOUND)
include_directories(${PNG_INCLUDE_DIR})
target_link_libraries(mapcache ${PNG_LIBRARIES})
else(PNG_FOUND)
report_mandatory_not_found(PNG)
endif(PNG_FOUND)
find_package(JPEG)
if(JPEG_FOUND)
include_directories(${JPEG_INCLUDE_DIR})
target_link_libraries(mapcache ${JPEG_LIBRARY})
else(JPEG_FOUND)
report_mandatory_not_found(JPEG)
endif(JPEG_FOUND)
find_package(CURL)
if(CURL_FOUND)
include_directories(${CURL_INCLUDE_DIR})
target_link_libraries(mapcache ${CURL_LIBRARY})
else(CURL_FOUND)
report_mandatory_not_found(CURL)
endif(CURL_FOUND)
find_package(APR)
if(APR_FOUND)
include_directories(${APR_INCLUDE_DIR} ${APU_INCLUDE_DIR})
target_link_libraries(mapcache ${APR_LIBRARY} ${APU_LIBRARY})
if(DEFINED APR_CPPFLAGS)
add_definitions("${APR_CPPFLAGS}")
endif(DEFINED APR_CPPFLAGS)
else(APR_FOUND)
report_mandatory_not_found(APR)
endif(APR_FOUND)
if(WITH_MEMCACHE)
include(CheckSymbolExists)
FIND_PATH(tmp_APU_MEMCACHE_DIR
NAMES apr_memcache.h
HINTS ${APU_INCLUDE_DIR}
)
if(tmp_APU_MEMCACHE_DIR)
set(CMAKE_REQUIRED_INCLUDE ${APR_INCLUDE_DIR} ${APU_INCLUDE_DIR})
set(CMAKE_REQUIRED_LIBRARIES ${APR_LIBRARY} ${APU_LIBRARY})
check_symbol_exists(apr_memcache_hash "${tmp_APU_MEMCACHE_DIR}/apr_memcache.h" tmp_MEMCACHE_USABLE)
if(tmp_MEMCACHE_USABLE)
set(USE_MEMCACHE 1)
else(tmp_MEMCACHE_USABLE)
MESSAGE(SEND_ERROR "apr_memcache.h found, but seems too old (missing apr_memcache_hash function)")
report_optional_not_found(MEMCACHE)
endif(tmp_MEMCACHE_USABLE)
else(tmp_APU_MEMCACHE_DIR)
MESSAGE(SEND_ERROR "apr_memcache.h not found, your apr-util version may be configured without memcache support")
report_optional_not_found(MEMCACHE)
endif(tmp_APU_MEMCACHE_DIR)
endif(WITH_MEMCACHE)
if(WITH_REDIS)
find_package(Redis)
if(HIREDIS_FOUND)
include_directories(${HIREDIS_INCLUDE_DIR})
target_link_libraries(mapcache ${HIREDIS_LIBRARIES})
set (USE_REDIS 1)
else(HIREDIS_FOUND)
report_optional_not_found(Redis)
endif(HIREDIS_FOUND)
endif(WITH_REDIS)
if(WITH_PIXMAN)
find_package(Pixman)
if(PIXMAN_FOUND)
include_directories(${PIXMAN_INCLUDE_DIR})
target_link_libraries(mapcache ${PIXMAN_LIBRARY})
set (USE_PIXMAN 1)
else(PIXMAN_FOUND)
report_optional_not_found(PIXMAN)
endif(PIXMAN_FOUND)
endif (WITH_PIXMAN)
if(WITH_GDAL)
find_package(GDAL)
if(GDAL_FOUND)
include_directories(${GDAL_INCLUDE_DIR})
target_link_libraries(mapcache ${GDAL_LIBRARY})
set (USE_GDAL 1)
else(GDAL_FOUND)
report_optional_not_found(GDAL)
endif(GDAL_FOUND)
endif(WITH_GDAL)
if(WITH_PCRE)
find_package(PCRE)
if(PCRE_FOUND)
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)
endif (WITH_PCRE)
if(WITH_PCRE2)
find_package(PCRE2)
if(PCRE2_FOUND)
include_directories(${PCRE2_INCLUDE_DIR})
target_link_libraries(mapcache PCRE2::PCRE2-8)
set (USE_PCRE2 1)
add_definitions(-DPCRE2_CODE_UNIT_WIDTH=8)
else(PCRE2_FOUND)
report_optional_not_found(PCRE2)
endif(PCRE2_FOUND)
endif (WITH_PCRE2)
if(WITH_SQLITE)
find_package(SQLITE)
if(SQLITE_FOUND)
include_directories(${SQLITE_INCLUDE_DIR})
target_link_libraries(mapcache ${SQLITE_LIBRARY})
set (USE_SQLITE 1)
else(SQLITE_FOUND)
report_optional_not_found(SQLITE)
endif(SQLITE_FOUND)
endif (WITH_SQLITE)
if(WITH_POSTGRESQL)
find_package(PostgreSQL)
if(PostgreSQL_FOUND)
include_directories(${PostgreSQL_INCLUDE_DIR})
target_link_libraries(mapcache ${PostgreSQL_LIBRARY})
set (USE_POSTGRESQL 1)
else(POSTGRESQL_FOUND)
report_optional_not_found(POSTGRESQL)
endif(PostgreSQL_FOUND)
endif (WITH_POSTGRESQL)
if(WITH_BERKELEY_DB)
if(NOT BERKELEYDB_FIND_VERSION)
set(BERKELEYDB_FIND_VERSION "4.6")
endif(NOT BERKELEYDB_FIND_VERSION)
find_package(BerkeleyDB)
if(BERKELEYDB_FOUND)
include_directories(${BERKELEYDB_INCLUDE_DIR})
target_link_libraries(mapcache ${BERKELEYDB_LIBRARY})
set (USE_BDB 1)
else(BERKELEYDB_FOUND)
report_optional_not_found(BERKELEY_DB)
endif(BERKELEYDB_FOUND)
endif (WITH_BERKELEY_DB)
if(WITH_LMDB)
if(NOT LMDB_FIND_VERSION)
set(LMDB_FIND_VERSION "0.9.10")
endif(NOT LMDB_FIND_VERSION)
find_package(LMDB)
if(LMDB_FOUND)
include_directories(${LMDB_INCLUDE_DIR})
target_link_libraries(mapcache ${LMDB_LIBRARY})
set(USE_LMDB 1)
else(LMDB_FOUND)
report_optional_not_found(LMDB)
endif(LMDB_FOUND)
endif(WITH_LMDB)
if(WITH_TIFF)
find_package(TIFF)
if(TIFF_FOUND)
include_directories(${TIFF_INCLUDE_DIR})
target_link_libraries(mapcache ${TIFF_LIBRARY})
set (USE_TIFF 1)
else(TIFF_FOUND)
report_optional_not_found(TIFF)
endif(TIFF_FOUND)
endif (WITH_TIFF)
if(WITH_TIFF_WRITE_SUPPORT)
if(USE_TIFF)
set (USE_TIFF_WRITE 1)
else(USE_TIFF)
report_dependency_error(TIFF_WRITE_SUPPORT TIFF)
endif(USE_TIFF)
endif(WITH_TIFF_WRITE_SUPPORT)
if(WITH_GEOTIFF)
find_package(GEOTIFF)
if(GEOTIFF_FOUND)
include_directories(${GEOTIFF_INCLUDE_DIR})
target_link_libraries(mapcache ${GEOTIFF_LIBRARY})
set (USE_GEOTIFF 1)
else(GEOTIFF_FOUND)
report_optional_not_found(GEOTIFF)
endif(GEOTIFF_FOUND)
endif (WITH_GEOTIFF)
if(WITH_MAPSERVER)
find_package(MAPSERVER)
if(MAPSERVER_FOUND)
include_directories(${MAPSERVER_INCLUDE_DIR})
target_link_libraries(mapcache ${MAPSERVER_LIBRARY})
set (USE_MAPSERVER 1)
else(MAPSERVER_FOUND)
report_optional_not_found(MAPSERVER)
endif(MAPSERVER_FOUND)
endif (WITH_MAPSERVER)
if(WITH_RIAK)
find_package(RIAK)
if(RIAK_FOUND)
include_directories(${RIAK_INCLUDE_DIR})
target_link_libraries(mapcache ${RIAK_LIBRARY})
set (USE_RIAK 1)
else(RIAK_FOUND)
report_optional_not_found(RIAK)
endif(RIAK_FOUND)
endif (WITH_RIAK)
if(UNIX)
target_link_libraries(mapcache ${CMAKE_DL_LIBS} m )
endif(UNIX)
configure_file (
"${PROJECT_SOURCE_DIR}/include/mapcache-config.h.in"
"${PROJECT_BINARY_DIR}/include/mapcache-config.h"
)
configure_file (
"${PROJECT_SOURCE_DIR}/include/mapcache-version.h.in"
"${PROJECT_BINARY_DIR}/include/mapcache-version.h"
)
include_directories(include ${PROJECT_BINARY_DIR}/include)
macro(status_optional_component component enabled libpath)
if("${enabled}" EQUAL "1")
message(STATUS " * ${component}: ${libpath}")
else()
message(STATUS " * ${component}: disabled")
endif()
endmacro()
macro(status_optional_feature feature enabled)
if("${enabled}" EQUAL "1" OR "${enabled}" STREQUAL "ON")
message(STATUS " * ${feature}: ENABLED")
else()
message(STATUS " * ${feature}: disabled")
endif()
endmacro()
message(STATUS "* Configured options for the mapcache library")
message(STATUS " * Mandatory components")
message(STATUS " * png: ${PNG_LIBRARY}")
message(STATUS " * jpeg: ${JPEG_LIBRARY}")
message(STATUS " * Curl: ${CURL_LIBRARY}")
message(STATUS " * Apr: ${APR_LIBRARY}")
message(STATUS " * Optional components")
status_optional_component("PIXMAN" "${USE_PIXMAN}" "${PIXMAN_LIBRARY}")
status_optional_component("SQLITE" "${USE_SQLITE}" "${SQLITE_LIBRARY}")
status_optional_component("POSTGRESQL" "${USE_POSTGRESQL}" "${PostgreSQL_LIBRARY}")
status_optional_component("Berkeley DB" "${USE_BDB}" "${BERKELEYDB_LIBRARY}")
status_optional_component("LMDB" "${USE_LMDB}" "${LMDB_LIBRARY}")
status_optional_component("Memcache" "${USE_MEMCACHE}" "${APU_LIBRARY}")
status_optional_component("Redis" "${USE_REDIS}" "${HIREDIS_LIBRARIES} ${HIREDIS_INCLUDE_DIR}")
status_optional_component("TIFF" "${USE_TIFF}" "${TIFF_LIBRARY}")
status_optional_component("GeoTIFF" "${USE_GEOTIFF}" "${GEOTIFF_LIBRARY}")
status_optional_component("Experimental TIFF write support" "${USE_TIFF_WRITE}" "${TIFF_LIBRARY}")
status_optional_component("PCRE" "${USE_PCRE}" "${PCRE_LIBRARY}")
status_optional_component("PCRE2" "${USE_PCRE2}" "${PCRE2-8_LIBRARY}")
status_optional_component("Experimental mapserver support" "${USE_MAPSERVER}" "${MAPSERVER_LIBRARY}")
status_optional_component("RIAK" "${USE_RIAK}" "${RIAK_LIBRARY}")
status_optional_component("GDAL" "${USE_GDAL}" "${GDAL_LIBRARY}")
message(STATUS " * Optional features")
status_optional_feature("MAPCACHE_DETAIL" "${WITH_MAPCACHE_DETAIL}")
INSTALL(TARGETS mapcache DESTINATION ${CMAKE_INSTALL_LIBDIR})
add_subdirectory(util)
add_subdirectory(cgi)
add_subdirectory(apache)
add_subdirectory(nginx)
if (WITH_MAPCACHE_DETAIL)
add_subdirectory(contrib/mapcache_detail)
endif (WITH_MAPCACHE_DETAIL)
mapcache-rel-1-14-1/INSTALL.md 0000664 0000000 0000000 00000000725 14653160677 0015570 0 ustar 00root root 0000000 0000000 Unix compilation instructions
-----------------------------
MapCache now builds with CMake. It seems much happier if it can find apxs, which
means you might need apache2-prefork installed (on ubuntu `apt-get install apache2-prefork-dev`).
```
cd mapcache
mkdir build
cd build
cmake ..
make
sudo make install
```
Detailed instructions and configuration options are maintained in the MapCache
documentation :
https://mapserver.org/mapcache/install.html
mapcache-rel-1-14-1/LICENSE.md 0000664 0000000 0000000 00000002262 14653160677 0015542 0 ustar 00root root 0000000 0000000 MapCache Licensing
==================
Copyright (c) 2008-2024 Open Source Geospatial Foundation.
Copyright (c) 1996-2008 Regents of the University of Minnesota.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies of this Software or works derived from this Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
mapcache-rel-1-14-1/MIGRATION_GUIDE.md 0000664 0000000 0000000 00000004171 14653160677 0016727 0 ustar 00root root 0000000 0000000 Migrating from MapCache 1.12 to 1.14
====================================
* This is a security release, to handle a string formatting injection vulnerability,
and includes other changes.
No backward compatibility issue is expected.
See [MapCache 1.14 Changelog](https://mapserver.org/development/changelog/mapcache/changelog-1-14.html).
Migrating from MapCache 1.10 to 1.12
====================================
* No backward compatibility issue is expected.
See [MapCache 1.12 Changelog](https://mapserver.org/development/changelog/mapcache/changelog-1-12.html)
for a list of bug fixes and new features.
Migrating from MapCache 1.8 to 1.10
===================================
* No backward compatibility issue is expected.
See [MapCache 1.10 Changelog](https://mapserver.org/development/changelog/mapcache/changelog-1-10.html)
for a list of bug fixes and new features.
Migrating from MapCache 1.6 to 1.8
==================================
* ...SQL should be replaced by
...SQL... or
...SQL...
(see [RFC-121](https://mapserver.org/development/rfc/ms-rfc-121.html) for full examples)
Migrating from MapCache 1.4 to 1.6
==================================
* The tileset child has been removed. Time dimensions are now added with
* val1,val2,val3 should be replaced by
val1val2val3
* ... should be replaced by
true....
* ^abc$ should be replaced by
^abc$
* ... should be replaced by
stack....
mapcache-rel-1-14-1/Makefile.vc 0000664 0000000 0000000 00000005463 14653160677 0016213 0 ustar 00root root 0000000 0000000 #
# makefile.vc - Main mapcache makefile for MSVC++
#
#
# To use the makefile:
# - Open a DOS prompt window
# - Run the VCVARS32.BAT script to initialize the VC++ environment variables
# - Start the build with: nmake /f makefile.vc
#
# $Id: $
#
!INCLUDE nmake.opt
BASE_CFLAGS = $(OPTFLAGS)
CFLAGS=$(BASE_CFLAGS) $(MAPCACHE_CFLAGS)
CC= cl
LINK= link
#
# Main mapcache library.
#
MAPCACHE_OBJS = lib\axisorder.obj lib\dimension.obj lib\imageio_mixed.obj lib\service_wms.obj \
lib\buffer.obj lib\ezxml.obj lib\imageio_png.obj lib\service_wmts.obj \
lib\cache_disk.obj lib\lock.obj lib\services.obj lib\cache_bdb.obj \
lib\cache_memcache.obj lib\grid.obj lib\source.obj \
lib\cache_sqlite.obj lib\http.obj lib\source_gdal.obj lib\source_dummy.obj \
lib\cache_tiff.obj lib\image.obj lib\service_demo.obj lib\source_mapserver.obj \
lib\configuration.obj lib\image_error.obj lib\service_kml.obj lib\source_wms.obj \
lib\configuration_xml.obj lib\imageio.obj lib\service_tms.obj lib\tileset.obj \
lib\core.obj lib\imageio_jpeg.obj lib\service_ve.obj lib\util.obj lib\strptime.obj \
$(REGEX_OBJ)
MAPCACHE_FCGI = mapcache.exe
MAPCACHE_APACHE = mod_mapcache.dll
MAPCACHE_SEED = mapcache_seed.exe
#
#
#
default: all
all: $(MAPCACHE_LIB) $(MAPCACHE_FCGI) $(MAPCACHE_APACHE) $(MAPCACHE_SEED)
$(MAPCACHE_LIB): $(MAPCACHE_OBJS)
lib /debug /out:$(MAPCACHE_LIB) $(MAPCACHE_OBJS)
$(MAPCACHE_FCGI): $(MAPCACHE_LIB)
$(CC) $(CFLAGS) cgi\mapcache.c /Fecgi\mapcache.exe $(LIBS)
if exist cgi\$(MAPCACHE_FCGI).manifest mt -manifest cgi\$(MAPCACHE_FCGI).manifest -outputresource:cgi\$(MAPCACHE_FCGI);1
$(MAPCACHE_APACHE): $(MAPCACHE_LIB)
$(CC) $(CFLAGS) apache\mod_mapcache.c /link /DLL /out:apache\mod_mapcache.dll $(LIBS)
if exist apache\$(MAPCACHE_APACHE).manifest mt -manifest apache\$(MAPCACHE_APACHE).manifest -outputresource:apache\$(MAPCACHE_APACHE);2
$(MAPCACHE_SEED): $(MAPCACHE_LIB)
$(CC) $(CFLAGS) util\mapcache_seed.c /Feutil\mapcache_seed.exe $(LIBS)
if exist util\$(MAPCACHE_SEED).manifest mt -manifest util\$(MAPCACHE_SEED).manifest -outputresource:util\$(MAPCACHE_SEED);1
.c.obj:
$(CC) $(CFLAGS) /c $*.c /Fo$*.obj
.cpp.obj:
$(CC) $(CFLAGS) /c $*.cpp /Fo$*.obj
clean:
del lib\*.obj
del *.obj
del *.exp
del apache\$(MAPCACHE_APACHE)
del apache\*.manifest
del apache\*.exp
del apache\*.lib
del apache\*.pdb
del apache\*.ilk
del cgi\$(MAPCACHE_FCGI)
del cgi\*.manifest
del cgi\*.exp
del cgi\*.lib
del cgi\*.pdb
del cgi\*.ilk
del util\$(MAPCACHE_SEED)
del util\*.manifest
del util\*.exp
del util\*.lib
del util\*.pdb
del util\*.ilk
del *.lib
del *.manifest
install: $(MAPCACHE_EXE)
-mkdir $(BINDIR)
copy *.exe $(BINDIR)
mapcache-rel-1-14-1/README.md 0000664 0000000 0000000 00000002025 14653160677 0015412 0 ustar 00root root 0000000 0000000 MapCache
========
[](https://github.com/MapServer/mapcache/actions?query=workflow%3A%22Build%20MapCache%20on%20Linux%22%20branch%3Amain)
[](https://github.com/MapServer/mapcache/actions?query=workflow%3A%22Build%20MapCache%20on%20Windows%22%20branch%3Amain)
Summary
-------
MapCache is a server that implements tile caching to speed up access to WMS layers.
The primary objectives are to be fast and easily deployable, while offering the
essential features (and more!) expected from a tile caching solution.
For more information and complete documentation please
visit:
https://mapserver.org/mapcache/
Questions relating to MapCache use and development can be asked on the
MapServer mailing lists:
https://mapserver.org/community/lists.html
License
-------
See [LICENSE.md](LICENSE.md) mapcache-rel-1-14-1/Vagrantfile 0000664 0000000 0000000 00000001347 14653160677 0016326 0 ustar 00root root 0000000 0000000 # -*- mode: ruby -*-
# vi: set ft=ruby :
require 'socket'
# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "ubuntu/focal64"
config.vm.hostname = "mapcache-vagrant"
config.vm.network :forwarded_port, guest: 80, host: 8080
config.vm.provider "virtualbox" do |v|
v.customize ["modifyvm", :id, "--memory", 1024, "--cpus", 2]
v.customize ["modifyvm", :id, "--ioapic", "on", "--largepages", "off", "--vtxvpid", "off"]
v.name = "mapcache-vagrant"
end
config.vm.provision "shell", path: "scripts/vagrant/packages.sh"
config.vm.provision "shell", path: "scripts/vagrant/mapcache.sh"
end
mapcache-rel-1-14-1/apache/ 0000775 0000000 0000000 00000000000 14653160677 0015355 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/apache/CMakeLists.txt 0000664 0000000 0000000 00000003130 14653160677 0020112 0 ustar 00root root 0000000 0000000 option(WITH_VERSION_STRING "Show MapCache in server version string" ON)
option(WITH_APACHE "Build Apache Module" ON)
if(WITH_APACHE)
add_library(mod_mapcache MODULE mod_mapcache.c)
set_target_properties(mod_mapcache PROPERTIES PREFIX "")
target_link_libraries(mod_mapcache mapcache)
find_package(APACHE)
if(APACHE_FOUND)
include_directories(${APACHE_INCLUDE_DIR})
target_link_libraries(mod_mapcache ${APACHE_LIBRARY})
else(APACHE_FOUND)
report_mandatory_not_found(APACHE)
endif(APACHE_FOUND)
if(WITH_VERSION_STRING)
set(USE_VERSION_STRING 1)
endif(WITH_VERSION_STRING)
configure_file (
"${PROJECT_SOURCE_DIR}/apache/mod_mapcache-config.h.in"
"${PROJECT_BINARY_DIR}/apache/mod_mapcache-config.h"
)
include_directories("${PROJECT_BINARY_DIR}/apache/")
IF(APPLE)
set_target_properties(mod_mapcache PROPERTIES
LINK_FLAGS "-Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
ENDIF(APPLE)
message(STATUS "* Apache Module support status:")
status_optional_component("Mapcache Version String" "${USE_VERSION_STRING}" "mod_mapcache/${MAPCACHE_VERSION_STRING}")
if(APACHE_MODULE_DIR)
message(STATUS " * Module will be installed to : ${APACHE_MODULE_DIR}")
else(APACHE_MODULE_DIR)
message(WARNING " * Module will not be automatically installed: module directory not found")
endif(APACHE_MODULE_DIR)
if(APACHE_MODULE_DIR)
INSTALL(TARGETS mod_mapcache DESTINATION ${APACHE_MODULE_DIR})
endif(APACHE_MODULE_DIR)
else(WITH_APACHE)
message(STATUS " * Apache Module support status: DISABLED")
endif(WITH_APACHE)
mapcache-rel-1-14-1/apache/mod_mapcache-config.h.in 0000664 0000000 0000000 00000000151 14653160677 0021773 0 ustar 00root root 0000000 0000000 #ifndef _MOD_MAPCACHE_CONFIG_H
#define _MOD_MAPCACHE_CONFIG_H
#cmakedefine USE_VERSION_STRING 1
#endif
mapcache-rel-1-14-1/apache/mod_mapcache.c 0000664 0000000 0000000 00000061515 14653160677 0020131 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching apache module implementation
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
/*
* Include the core server components.
*/
#include "mod_mapcache-config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include "mapcache.h"
#ifndef _WIN32
#include
#endif
#ifdef AP_NEED_SET_MUTEX_PERMS
#include "unixd.h"
#endif
module AP_MODULE_DECLARE_DATA mapcache_module;
typedef struct mapcache_context_apache mapcache_context_apache;
typedef struct mapcache_context_apache_request mapcache_context_apache_request;
typedef struct mapcache_context_apache_server mapcache_context_apache_server;
struct mapcache_context_apache {
mapcache_context ctx;
};
struct mapcache_context_apache_server {
mapcache_context_apache ctx;
server_rec *server;
};
struct mapcache_context_apache_request {
mapcache_context_apache ctx;
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 */
apr_array_header_t *quickaliases; /**< list of mapcache configurations aliased to a server uri */
};
static int mapcache_alias_matches(const char *uri, const char *alias_fakename);
void apache_context_server_log(mapcache_context *c, mapcache_log_level level, char *message, ...)
{
mapcache_context_apache_server *ctx = (mapcache_context_apache_server*)c;
va_list args;
char *msg;
int ap_log_level;
va_start(args,message);
msg = apr_pvsprintf(c->pool,message,args);
va_end(args);
switch(level) {
case MAPCACHE_DEBUG:
ap_log_level = APLOG_DEBUG;
break;
case MAPCACHE_INFO:
ap_log_level = APLOG_INFO;
break;
case MAPCACHE_NOTICE:
ap_log_level = APLOG_NOTICE;
break;
case MAPCACHE_WARN:
ap_log_level = APLOG_WARNING;
break;
case MAPCACHE_ERROR:
ap_log_level = APLOG_ERR;
break;
case MAPCACHE_CRIT:
ap_log_level = APLOG_CRIT;
break;
case MAPCACHE_ALERT:
ap_log_level = APLOG_ALERT;
break;
case MAPCACHE_EMERG:
ap_log_level = APLOG_EMERG;
break;
default:
ap_log_level = APLOG_WARNING;
}
ap_log_error(APLOG_MARK, ap_log_level, 0, ctx->server,"%s",msg);
}
void apache_context_request_log(mapcache_context *c, mapcache_log_level level, char *message, ...)
{
mapcache_context_apache_request *ctx = (mapcache_context_apache_request*)c;
va_list args;
char *res;
int ap_log_level;
va_start(args,message);
res = apr_pvsprintf(c->pool, message, args);
va_end(args);
switch(level) {
case MAPCACHE_DEBUG:
ap_log_level = APLOG_DEBUG;
break;
case MAPCACHE_INFO:
ap_log_level = APLOG_INFO;
break;
case MAPCACHE_NOTICE:
ap_log_level = APLOG_NOTICE;
break;
case MAPCACHE_WARN:
ap_log_level = APLOG_WARNING;
break;
case MAPCACHE_ERROR:
ap_log_level = APLOG_ERR;
break;
case MAPCACHE_CRIT:
ap_log_level = APLOG_CRIT;
break;
case MAPCACHE_ALERT:
ap_log_level = APLOG_ALERT;
break;
case MAPCACHE_EMERG:
ap_log_level = APLOG_EMERG;
break;
default:
ap_log_level = APLOG_WARNING;
}
ap_log_rerror(APLOG_MARK, ap_log_level, 0, ctx->request, "%s", res);
}
mapcache_context *mapcache_context_request_clone(mapcache_context *ctx)
{
mapcache_context_apache_request *newctx = (mapcache_context_apache_request*)apr_pcalloc(ctx->pool,
sizeof(mapcache_context_apache_request));
mapcache_context *nctx = (mapcache_context*)newctx;
mapcache_context_copy(ctx,nctx);
//apr_pool_create(&nctx->pool,ctx->pool);
apr_pool_create(&nctx->pool,NULL);
apr_pool_cleanup_register(ctx->pool, nctx->pool,(void*)apr_pool_destroy, apr_pool_cleanup_null);
newctx->request = ((mapcache_context_apache_request*)ctx)->request;
return nctx;
}
mapcache_context_apache_request* create_apache_request_context(request_rec *r)
{
mapcache_context_apache_request *rctx = apr_pcalloc(r->pool, sizeof(mapcache_context_apache_request));
mapcache_context *ctx = (mapcache_context*)rctx;
mapcache_context_init(ctx);
ctx->pool = r->pool;
rctx->request = r;
ctx->log = apache_context_request_log;
ctx->clone = mapcache_context_request_clone;
return rctx;
}
static mapcache_context_apache_server* create_apache_server_context(server_rec *s, apr_pool_t *pool)
{
mapcache_context_apache_server *actx = apr_pcalloc(pool, sizeof(mapcache_context_apache_server));
mapcache_context *ctx = (mapcache_context*)actx;
mapcache_context_init(ctx);
ctx->pool = pool;
ctx->config = NULL;
ctx->log = apache_context_server_log;
actx->server = s;
return actx;
}
/* read post body. code taken from "The apache modules book, Nick Kew" */
static void read_post_body(mapcache_context_apache_request *ctx, mapcache_request_proxy *p) {
request_rec *r = ctx->request;
mapcache_context *mctx = (mapcache_context*)ctx;
int bytes,eos;
apr_bucket_brigade *bb, *bbin;
apr_bucket *b;
apr_status_t rv;
const char *clen = apr_table_get(r->headers_in, "Content-Length");
if(clen) {
bytes = strtol(clen, NULL, 0);
if(bytes >= p->rule->max_post_len) {
mctx->set_error(mctx, HTTP_REQUEST_ENTITY_TOO_LARGE, "post request too big");
return;
}
} 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 = 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(p->post_len <= p->rule->max_post_len) {
APR_BUCKET_REMOVE(b);
APR_BRIGADE_INSERT_TAIL(bb, b);
}
}
} while (!eos);
if(p->post_len > p->rule->max_post_len) {
mctx->set_error(mctx, HTTP_REQUEST_ENTITY_TOO_LARGE, "request too big");
return;
}
p->post_buf = apr_palloc(mctx->pool, p->post_len+1);
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;
}
static int write_http_response(mapcache_context_apache_request *ctx, mapcache_http_response *response)
{
request_rec *r = ctx->request;
int rc;
char *timestr;
if(response->mtime) {
ap_update_mtime(r, response->mtime);
if((rc = ap_meets_conditions(r)) != OK) {
return rc;
}
timestr = apr_palloc(r->pool, APR_RFC822_DATE_LEN);
apr_rfc822_date(timestr, response->mtime);
apr_table_setn(r->headers_out, "Last-Modified", timestr);
}
if(response->headers && !apr_is_empty_table(response->headers)) {
const apr_array_header_t *elts = apr_table_elts(response->headers);
int i;
for(i=0; inelts; i++) {
apr_table_entry_t entry = APR_ARRAY_IDX(elts,i,apr_table_entry_t);
if(!strcasecmp(entry.key,"Content-Type")) {
ap_set_content_type(r,entry.val);
} else {
apr_table_set(r->headers_out, entry.key, entry.val);
}
}
}
if(response->data && response->data->size) {
ap_set_content_length(r,response->data->size);
ap_rwrite((void*)response->data->buf, response->data->size, r);
}
r->status = response->code;
return OK;
}
static void mod_mapcache_child_init(apr_pool_t *pool, server_rec *s)
{
mapcache_context *ctx;
ctx = (mapcache_context*)create_apache_server_context(s,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;ialiases->nelts;i++) {
mapcache_alias_entry *alias_entry = APR_ARRAY_IDX(cfg->aliases,i,mapcache_alias_entry*);
mapcache_cache_child_init(ctx,alias_entry->cfg,pool);
if (GC_HAS_ERROR(ctx)) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "%s", ctx->get_error_message(ctx));
}
rv = mapcache_connection_pool_create(alias_entry->cfg, &(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");
}
}
for(i=0;iquickaliases->nelts;i++) {
mapcache_alias_entry *alias_entry = APR_ARRAY_IDX(cfg->quickaliases,i,mapcache_alias_entry*);
mapcache_cache_child_init(ctx,alias_entry->cfg,pool);
if (GC_HAS_ERROR(ctx)) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "%s", ctx->get_error_message(ctx));
}
rv = mapcache_connection_pool_create(alias_entry->cfg, &(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");
}
}
}
}
static int mapcache_handler(request_rec *r, mapcache_alias_entry *alias_entry) {
apr_table_t *params;
mapcache_request *request = NULL;
mapcache_context_apache_request *apache_ctx = create_apache_request_context(r);
mapcache_context *ctx = (mapcache_context*)apache_ctx;
mapcache_http_response *http_response = NULL;
ctx->config = alias_entry->cfg;
ctx->connection_pool = alias_entry->cp;
ctx->supports_redirects = 1;
ctx->headers_in = r->headers_in;
params = mapcache_http_parse_param_string(ctx, r->args);
//ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "mapcache dispatch %s",r->path_info);
mapcache_service_dispatch_request(ctx,&request,r->path_info,params,ctx->config);
if(GC_HAS_ERROR(ctx) || !request) {
return write_http_response(apache_ctx,
mapcache_core_respond_to_error(ctx));
}
if(request->type == MAPCACHE_REQUEST_GET_CAPABILITIES) {
mapcache_request_get_capabilities *req_caps = (mapcache_request_get_capabilities*)request;
request_rec *original;
char *url;
if(r->main)
original = r->main;
else
original = r;
url = ap_construct_url(r->pool,original->uri,original);
/*
* remove the path_info from the end of the url (we want the url of the base of the service)
* TODO: is there an apache api to access this ?
*/
if(*(original->path_info) && strcmp(original->path_info,"/")) {
char *end = strstr(url,original->path_info);
if(end) {
/* make sure our url ends with a single '/' */
if(*end == '/') {
char *slash = end;
while((*(--slash))=='/') end--;
end++;
}
*end = '\0';
}
}
http_response = mapcache_core_get_capabilities(ctx,request->service,req_caps,
url,original->path_info,ctx->config);
} else if( request->type == MAPCACHE_REQUEST_GET_TILE) {
mapcache_request_get_tile *req_tile = (mapcache_request_get_tile*)request;
http_response = mapcache_core_get_tile(ctx,req_tile);
} else if( request->type == MAPCACHE_REQUEST_PROXY ) {
const char *buf;
mapcache_request_proxy *req_proxy = (mapcache_request_proxy*)request;
if(r->method_number == M_POST) {
read_post_body(apache_ctx, req_proxy);
if(GC_HAS_ERROR(ctx)) {
return write_http_response(apache_ctx, mapcache_core_respond_to_error(ctx));
}
if(!req_proxy->headers) {
req_proxy->headers = apr_table_make(ctx->pool, 2);
}
apr_table_set(req_proxy->headers, "Content-Type", r->content_type);
if((buf = apr_table_get(r->headers_in,"X-Forwarded-For"))) {
#if (AP_SERVER_MAJORVERSION_NUMBER == 2) && (AP_SERVER_MINORVERSION_NUMBER < 4)
apr_table_set(req_proxy->headers, "X-Forwarded-For", apr_psprintf(ctx->pool,"%s, %s", buf, r->connection->remote_ip));
#else
apr_table_set(req_proxy->headers, "X-Forwarded-For", apr_psprintf(ctx->pool,"%s, %s", buf, r->connection->client_ip));
#endif
} else {
#if (AP_SERVER_MAJORVERSION_NUMBER == 2) && (AP_SERVER_MINORVERSION_NUMBER < 4)
apr_table_set(req_proxy->headers, "X-Forwarded-For", r->connection->remote_ip);
#else
apr_table_set(req_proxy->headers, "X-Forwarded-For", r->connection->client_ip);
#endif
}
if ((buf = apr_table_get(r->headers_in, "Host"))) {
const char *buf2;
if((buf2 = apr_table_get(r->headers_in,"X-Forwarded-Host"))) {
apr_table_set(req_proxy->headers, "X-Forwarded-Host", apr_psprintf(ctx->pool,"%s, %s",buf2,buf));
} else {
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(ctx->pool, "%s, %s", buf, r->server->server_hostname));
} else {
apr_table_set(req_proxy->headers, "X-Forwarded-Server", r->server->server_hostname);
}
}
http_response = mapcache_core_proxy_request(ctx, req_proxy);
} else if( request->type == MAPCACHE_REQUEST_GET_MAP) {
mapcache_request_get_map *req_map = (mapcache_request_get_map*)request;
http_response = mapcache_core_get_map(ctx,req_map);
} else if( request->type == MAPCACHE_REQUEST_GET_FEATUREINFO) {
mapcache_request_get_feature_info *req_fi = (mapcache_request_get_feature_info*)request;
http_response = mapcache_core_get_featureinfo(ctx,req_fi);
} else {
ctx->set_error(ctx,500,"###BUG### unknown request type");
}
if(GC_HAS_ERROR(ctx)) {
return write_http_response(apache_ctx,
mapcache_core_respond_to_error(ctx));
}
return write_http_response(apache_ctx,http_response);
}
static int mod_mapcache_quick_handler(request_rec *r, int lookup) {
mapcache_server_cfg *sconfig = ap_get_module_config(r->server->module_config, &mapcache_module);
mapcache_alias_entry *alias_entry;
int i;
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "mapcache quick handler hook on uri %s",r->uri);
if (!sconfig || !sconfig->quickaliases)
return DECLINED;
if (r->uri[0] != '/' && r->uri[0])
return DECLINED;
if(lookup) {
return DECLINED;
}
/* loop through the entries to find one where the alias matches */
for(i=0; iquickaliases->nelts; i++) {
int l;
alias_entry = APR_ARRAY_IDX(sconfig->quickaliases,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) {
if (r->method_number != M_GET && r->method_number != M_POST) {
return HTTP_METHOD_NOT_ALLOWED;
}
r->path_info = &(r->uri[l]);
return mapcache_handler(r,alias_entry);
}
}
return DECLINED;
}
static int mod_mapcache_request_handler(request_rec *r)
{
const char *mapcache_alias;
int i;
mapcache_server_cfg* cfg;
if (!r->handler || strcmp(r->handler, "mapcache")) {
return DECLINED;
}
if (r->method_number != M_GET && r->method_number != M_POST) {
return HTTP_METHOD_NOT_ALLOWED;
}
cfg = ap_get_module_config(r->server->module_config, &mapcache_module);
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 DECLINED;
}
for(i=0; ialiases->nelts; i++) {
mapcache_alias_entry *alias_entry = APR_ARRAY_IDX(cfg->aliases,i,mapcache_alias_entry*);
if(strcmp(alias_entry->endpoint,mapcache_alias))
continue;
return mapcache_handler(r,alias_entry);
}
return DECLINED; /*should never happen, the fixup phase would not have oriented us here*/
}
static int mod_mapcache_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
mapcache_server_cfg* cfg = ap_get_module_config(s->module_config, &mapcache_module);
if(!cfg) {
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);
#endif
return 0;
}
static int mapcache_alias_matches(const char *uri, const char *alias_fakename)
{
/* Code for this function from Apache mod_alias module. */
const char *aliasp = alias_fakename, *urip = uri;
while (*aliasp) {
if (*aliasp == '/') {
/* any number of '/' in the alias matches any number in
* the supplied URI, but there must be at least one...
*/
if (*urip != '/')
return 0;
do {
++aliasp;
} while (*aliasp == '/');
do {
++urip;
} while (*urip == '/');
} else {
/* Other characters are compared literally */
if (*urip++ != *aliasp++)
return 0;
}
}
/* Check last alias path component matched all the way */
if (aliasp[-1] != '/' && *urip != '\0' && *urip != '/')
return 0;
/* Return number of characters from URI which matched (may be
* greater than length of alias, since we may have matched
* doubled slashes)
*/
return urip - uri;
}
static int mapcache_hook_fixups(request_rec *r)
{
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; ialiases->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;
}
}
}
return DECLINED;
}
static void mod_mapcache_register_hooks(apr_pool_t *p)
{
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_quick_handler(mod_mapcache_quick_handler, NULL, NULL, 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 = apr_array_make(pool,1,sizeof(mapcache_alias_entry*));
cfg->quickaliases = apr_array_make(pool,1,sizeof(mapcache_alias_entry*));
return cfg;
}
static void *mod_mapcache_merge_server_conf(apr_pool_t *p, void *base_, void *vhost_)
{
mapcache_server_cfg *base = (mapcache_server_cfg*)base_;
mapcache_server_cfg *vhost = (mapcache_server_cfg*)vhost_;
mapcache_server_cfg *cfg = apr_pcalloc(p,sizeof(mapcache_server_cfg));
cfg->aliases = apr_array_append(p, vhost->aliases,base->aliases);
cfg->quickaliases = apr_array_append(p, vhost->quickaliases,base->quickaliases);
#if 0
{
mapcache_alias_entry *e;
int i;
fprintf(stderr,"#### merge called ####\n");
for(i=0;ialiases->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;ialiases->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;ialiases->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);
}
}
#endif
return cfg;
}
static const char* mapcache_add_alias(cmd_parms *cmd, void *cfg, const char *alias, const char* configfile, const char *quick)
{
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*)create_apache_server_context(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, alias_entry->cfg);
if(GC_HAS_ERROR(ctx)) {
return ctx->get_error_message(ctx);
}
if(mapcache_config_services_enabled(ctx, alias_entry->cfg) <= 0) {
return "no mapcache s configured/enabled, no point in continuing.";
}
if(quick && !strcmp(quick,"quick")) {
APR_ARRAY_PUSH(sconfig->quickaliases,mapcache_alias_entry*) = alias_entry;
ap_log_error(APLOG_MARK, APLOG_INFO, 0, cmd->server, "loaded mapcache configuration file from %s on (quick) endpoint %s", alias_entry->configfile, alias_entry->endpoint);
} else {
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;
}
static const command_rec mod_mapcache_cmds[] = {
AP_INIT_TAKE23("MapCacheAlias", mapcache_add_alias ,NULL,RSRC_CONF,"Aliased location of configuration file"),
{ NULL }
} ;
#ifdef APLOG_USE_MODULE
APLOG_USE_MODULE(mapcache);
#endif
module AP_MODULE_DECLARE_DATA mapcache_module = {
STANDARD20_MODULE_STUFF,
NULL,
NULL,
mod_mapcache_create_server_conf,
mod_mapcache_merge_server_conf,
mod_mapcache_cmds,
mod_mapcache_register_hooks
};
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/astyle.sh 0000775 0000000 0000000 00000000257 14653160677 0016000 0 ustar 00root root 0000000 0000000 #!/bin/bash
ASTYLEOPTS="--style=kr --indent=spaces=2 -c --lineend=linux -S"
ASTYLEBIN=astyle
$ASTYLEBIN $ASTYLEOPTS -R '*.c' '*.h'
#find . -name '*.orig' -exec rm -f {} \;
mapcache-rel-1-14-1/benchmark.py 0000664 0000000 0000000 00000004217 14653160677 0016444 0 ustar 00root root 0000000 0000000 #! /usr/bin/env python
import commands
import os
import re
def do_ab_call(url,nthreads,reqs):
cmd="ab -k -c %d -n %d '%s'" % (nthreads,reqs,url)
print cmd
summary={}
ret = commands.getoutput(cmd)
sList = ret.split(os.linesep)
for i, line in enumerate(sList):
if re.match("Requests per second", line) is not None:
val = line.split()
summary['reqspersec']=val[3]
if re.match("Document Length", line) is not None:
val = line.split()
summary['size']=val[2]
return summary
base="http://localhost:8081"
params="LAYERS=test,test3&FORMAT=image%2Fpng&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&STYLES=&EXCEPTIONS=application%2Fvnd.ogc.se_inimage&SRS=EPSG%3A4326&BBOX=-2.8125,47.8125,0,50.625&WIDTH=256&HEIGHT=256"
urls={}
nreqs=400
title="tile merging"
filebase=title
urls['tilecache']="%s/%s?%s" % (base,'tilecache',params)
urls['mapcache best compression']="%s/%s?%s" % (base,'mapcache-best',params)
urls['mapcache default compression']="%s/%s?%s" % (base,'mapcache-default',params)
urls['mapcache fast compression']="%s/%s?%s" % (base,'mapcache-fast',params)
urls['mapcache png quantization']="%s/%s?%s" % (base,'mapcache-pngq',params)
#urls['mapproxy']="http://localhost:8080/service?%s" % (params)
plotfile = open("%s.plot"%(filebase),"w")
datafile = open("%s.dat"%(filebase),"w")
plotfile.write("set terminal pdf\nset key autotitle columnhead\nset output \"%s.pdf\"\nset style data lines\n"%(filebase))
plotfile.write("set xlabel \"concurrent requests\"\n")
plotfile.write("set ylabel \"throughput (requests/sec)\"\n")
plotfile.write("set title \"%s\"\n"%(title))
count=0
for title,url in urls.iteritems():
if count == 0:
plotfile.write("plot \"%s.dat\" using 2:xticlabel(1) index 0"%(filebase))
else:
plotfile.write(",\"\" using 2 index %d"%(count))
count += 1
for nthreads in [1,2,3,4]:
reqs = min(nthreads,4) * nreqs
res = do_ab_call(url,nthreads,reqs)
if nthreads == 1:
datafile.write("\n\nthreads \"%s (%s bytes)\"\n"%(title,res['size']))
datafile.write("%d %s\n"%(nthreads,res['reqspersec']))
plotfile.write("\n")
mapcache-rel-1-14-1/cgi/ 0000775 0000000 0000000 00000000000 14653160677 0014676 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/cgi/CMakeLists.txt 0000664 0000000 0000000 00000002207 14653160677 0017437 0 ustar 00root root 0000000 0000000 option(WITH_CGI "Choose if CGI executable should be built" ON)
option(WITH_FCGI "Choose if CGI executable should support FastCGI" ON)
if(WITH_CGI)
if(NOT DEFINED CMAKE_INSTALL_CGIBINDIR)
set(CMAKE_INSTALL_CGIBINDIR ${CMAKE_INSTALL_BINDIR})
endif(NOT DEFINED CMAKE_INSTALL_CGIBINDIR)
add_executable(mapcache.fcgi mapcache.c)
target_link_libraries(mapcache.fcgi mapcache)
if(WITH_FCGI)
find_package(FCGI)
if(FCGI_FOUND)
include_directories(${FCGI_INCLUDE_DIR})
target_link_libraries(mapcache.fcgi ${FCGI_LIBRARY})
set (USE_FASTCGI 1)
else(FCGI_FOUND)
report_optional_not_found(FCGI)
endif(FCGI_FOUND)
endif (WITH_FCGI)
configure_file (
"${PROJECT_SOURCE_DIR}/cgi/mapcache-cgi-config.h.in"
"${PROJECT_BINARY_DIR}/cgi/mapcache-cgi-config.h"
)
include_directories("${PROJECT_BINARY_DIR}/cgi/")
message(STATUS "* CGI Configuration Options:")
status_optional_component("FastCGI" "${USE_FASTCGI}" "${FCGI_LIBRARY}")
INSTALL(TARGETS mapcache.fcgi RUNTIME DESTINATION ${CMAKE_INSTALL_CGIBINDIR})
else(WITH_CGI)
message(STATUS "* CGI Configuration Options: DISABLED")
endif(WITH_CGI)
mapcache-rel-1-14-1/cgi/mapcache-cgi-config.h.in 0000664 0000000 0000000 00000000142 14653160677 0021215 0 ustar 00root root 0000000 0000000 #ifndef _MAPCACHE_CGI_CONFIG_H
#define _MAPCACHE_CGI_CONFIG_H
#cmakedefine USE_FASTCGI 1
#endif
mapcache-rel-1-14-1/cgi/mapcache.c 0000664 0000000 0000000 00000031157 14653160677 0016612 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching CGI and FastCGI main program
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache-cgi-config.h"
#include "mapcache.h"
#include
#include
#include
#include
#include
#include
#ifdef USE_FASTCGI
#include
#endif
#ifndef WIN32
extern char** environ;
#endif
typedef struct mapcache_context_fcgi mapcache_context_fcgi;
typedef struct mapcache_context_fcgi_request mapcache_context_fcgi_request;
static char *err400 = "Bad Request";
static char *err404 = "Not Found";
static char *err500 = "Internal Server Error";
static char *err501 = "Not Implemented";
static char *err502 = "Bad Gateway";
static char *errother = "No Description";
apr_pool_t *global_pool = NULL,*config_pool, *tmp_config_pool;
static char* err_msg(int code)
{
switch(code) {
case 400:
return err400;
case 404:
return err404;
case 500:
return err500;
case 501:
return err501;
case 502:
return err502;
default:
return errother;
}
}
struct mapcache_context_fcgi {
mapcache_context ctx;
};
static mapcache_context* fcgi_context_clone(mapcache_context *ctx)
{
mapcache_context_fcgi *newctx = (mapcache_context_fcgi*)apr_pcalloc(ctx->pool,
sizeof(mapcache_context_fcgi));
mapcache_context *nctx = (mapcache_context*)newctx;
mapcache_context_copy(ctx,nctx);
apr_pool_create(&nctx->pool,ctx->pool);
return nctx;
}
static void fcgi_context_log(mapcache_context *c, mapcache_log_level level, char *message, ...)
{
va_list args;
if(!c->config || level >= c->config->loglevel) {
va_start(args,message);
fprintf(stderr,"%s\n",apr_pvsprintf(c->pool,message,args));
va_end(args);
}
}
static void handle_signal(int signal)
{
apr_pool_destroy(global_pool);
exit(signal);
}
static mapcache_context_fcgi* fcgi_context_create()
{
mapcache_context_fcgi *ctx = apr_pcalloc(global_pool, sizeof(mapcache_context_fcgi));
if(!ctx) {
return NULL;
}
ctx->ctx.pool = global_pool;
mapcache_context_init((mapcache_context*)ctx);
ctx->ctx.log = fcgi_context_log;
ctx->ctx.clone = fcgi_context_clone;
ctx->ctx.config = NULL;
return ctx;
}
static void fcgi_write_response(mapcache_context_fcgi *ctx, mapcache_http_response *response)
{
if(response->code != 200) {
printf("Status: %ld %s\r\n",response->code, err_msg(response->code));
}
if(response->headers && !apr_is_empty_table(response->headers)) {
const apr_array_header_t *elts = apr_table_elts(response->headers);
int i;
for(i=0; inelts; i++) {
apr_table_entry_t entry = APR_ARRAY_IDX(elts,i,apr_table_entry_t);
printf("%s: %s\r\n", entry.key, entry.val);
}
}
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;
mtime = apr_time_sec(response->mtime);
ims_time = apr_date_parse_http(if_modified_since);
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;
}
}
}
if(response->data) {
printf("Content-Length: %ld\r\n\r\n", response->data->size);
fwrite((char*)response->data->buf, response->data->size,1,stdout);
}
}
apr_time_t mtime;
char *conffile;
static void load_config(mapcache_context *ctx, char *filename)
{
apr_file_t *f;
apr_finfo_t finfo;
mapcache_cfg *old_cfg;
mapcache_cfg *cfg;
if((apr_file_open(&f, filename, APR_FOPEN_READ, APR_UREAD | APR_GREAD,
global_pool)) == APR_SUCCESS) {
apr_file_info_get(&finfo, APR_FINFO_MTIME, f);
apr_file_close(f);
} else {
if(!ctx->pool) ctx->pool = global_pool;
ctx->set_error(ctx,500,"failed to open config file %s",filename);
return;
}
if(ctx->config) {
//we already have a loaded configuration, check that the config file hasn't changed
if(finfo.mtime > mtime) {
ctx->log(ctx,MAPCACHE_INFO,"config file has changed, reloading");
} else {
return;
}
}
mtime = finfo.mtime;
/* either we have no config, or it has changed */
old_cfg = ctx->config;
apr_pool_create(&tmp_config_pool,global_pool);
cfg = mapcache_configuration_create(tmp_config_pool);
ctx->config = cfg;
ctx->pool = tmp_config_pool;
mapcache_configuration_parse(ctx,conffile,cfg,1);
if(GC_HAS_ERROR(ctx)) goto failed_load;
mapcache_configuration_post_config(ctx, cfg);
if(GC_HAS_ERROR(ctx)) goto failed_load;
if(mapcache_config_services_enabled(ctx,cfg) <= 0) {
ctx->set_error(ctx,500,"no mapcache s configured/enabled, no point in continuing.");
goto failed_load;
}
/* no error, destroy the previous pool if we are reloading the config */
if(config_pool) {
apr_pool_destroy(config_pool);
}
config_pool = tmp_config_pool;
mapcache_cache_child_init(ctx,cfg,config_pool);
if (GC_HAS_ERROR(ctx)) goto failed_load;
mapcache_connection_pool_create(cfg, &ctx->connection_pool, config_pool);
return;
failed_load:
/* we failed to load the config file */
if(config_pool) {
/* we already have a running configuration, keep it and only log the error to not
* interrupt the already running service */
ctx->log(ctx,MAPCACHE_ERROR,"failed to reload config file %s: %s", conffile,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
ctx->config = old_cfg;
ctx->pool = config_pool;
apr_pool_destroy(tmp_config_pool);
}
}
static void set_headers(mapcache_context* ctx, char** env)
{
// add all environ settings including HTTP headers to
// a ctx->headers_in apr_table_t
char * key, * val, * kvp, * pair;
int i;
int num_env_var;
apr_table_t* headers;
num_env_var = 0;
while (env[num_env_var] != NULL)
num_env_var++;
headers = apr_table_make(ctx->pool, num_env_var);
for (i = 0; env[i] != NULL; i++) {
kvp = apr_pstrdup(ctx->pool, env[i]);
// convert HTTP header keys from the form HTTP_MY_HEADER to MY-HEADER
key = apr_strtok(kvp, "=", &pair);
key = mapcache_util_str_replace(ctx->pool, key, "HTTP_", "");
key = mapcache_util_str_replace_all(ctx->pool, key, "_", "-");
val = apr_strtok(NULL, "=", &pair);
if (val != NULL) {
apr_table_addn(headers, key, val);
}
else {
apr_table_addn(headers, key, "");
}
}
ctx->headers_in = headers;
}
int main(int argc, const char **argv)
{
mapcache_context_fcgi* globalctx;
mapcache_context* ctx;
apr_table_t *params;
mapcache_request *request = NULL;
char *pathInfo;
mapcache_http_response *http_response;
(void) signal(SIGTERM,handle_signal);
#ifndef _WIN32
(void) signal(SIGUSR1,handle_signal);
#endif
apr_initialize();
atexit(apr_terminate);
if(apr_pool_create(&global_pool,NULL) != APR_SUCCESS) {
return 1;
}
config_pool = NULL;
globalctx = fcgi_context_create();
ctx = (mapcache_context*)globalctx;
conffile = getenv("MAPCACHE_CONFIG_FILE");
#ifdef DEBUG
if(!conffile) {
int i;
for(i=1; ilog(ctx,MAPCACHE_INFO,"mapcache fcgi conf file: %s",conffile);
#ifdef USE_FASTCGI
while (FCGI_Accept() >= 0) {
#endif
ctx->pool = config_pool;
if(!ctx->config || ctx->config->autoreload) {
load_config(ctx,conffile);
if(GC_HAS_ERROR(ctx)) {
fcgi_write_response(globalctx, mapcache_core_respond_to_error(ctx));
goto cleanup;
}
}
apr_pool_create(&(ctx->pool),config_pool);
request = NULL;
pathInfo = getenv("PATH_INFO");
params = mapcache_http_parse_param_string(ctx, getenv("QUERY_STRING"));
mapcache_service_dispatch_request(ctx,&request,pathInfo,params,ctx->config);
if(GC_HAS_ERROR(ctx) || !request) {
fcgi_write_response(globalctx, mapcache_core_respond_to_error(ctx));
goto cleanup;
}
set_headers(ctx, environ);
http_response = NULL;
if(request->type == MAPCACHE_REQUEST_GET_CAPABILITIES) {
mapcache_request_get_capabilities *req = (mapcache_request_get_capabilities*)request;
char *host = getenv("SERVER_NAME");
char *port = getenv("SERVER_PORT");
char *fullhost;
char *url;
if(getenv("HTTPS")) {
if(!port || !strcmp(port,"443")) {
fullhost = apr_psprintf(ctx->pool,"https://%s",host);
} else {
fullhost = apr_psprintf(ctx->pool,"https://%s:%s",host,port);
}
} else {
if(!port || !strcmp(port,"80")) {
fullhost = apr_psprintf(ctx->pool,"http://%s",host);
} else {
fullhost = apr_psprintf(ctx->pool,"http://%s:%s",host,port);
}
}
url = apr_psprintf(ctx->pool,"%s%s/",
fullhost,
getenv("SCRIPT_NAME")
);
http_response = mapcache_core_get_capabilities(ctx,request->service,req,url,pathInfo,ctx->config);
} else if( request->type == MAPCACHE_REQUEST_GET_TILE) {
mapcache_request_get_tile *req_tile = (mapcache_request_get_tile*)request;
http_response = mapcache_core_get_tile(ctx,req_tile);
} else if( request->type == MAPCACHE_REQUEST_PROXY ) {
mapcache_request_proxy *req_proxy = (mapcache_request_proxy*)request;
http_response = mapcache_core_proxy_request(ctx, req_proxy);
// Content-Length is added again in fcgi_write_response
apr_table_unset(http_response->headers, "Content-Length");
} else if( request->type == MAPCACHE_REQUEST_GET_MAP) {
mapcache_request_get_map *req_map = (mapcache_request_get_map*)request;
http_response = mapcache_core_get_map(ctx,req_map);
} else if( request->type == MAPCACHE_REQUEST_GET_FEATUREINFO) {
mapcache_request_get_feature_info *req_fi = (mapcache_request_get_feature_info*)request;
http_response = mapcache_core_get_featureinfo(ctx,req_fi);
#ifdef DEBUG
} else {
ctx->set_error(ctx,500,"###BUG### unknown request type");
#endif
}
if(GC_HAS_ERROR(ctx)) {
fcgi_write_response(globalctx, mapcache_core_respond_to_error(ctx));
goto cleanup;
}
#ifdef DEBUG
if(!http_response) {
ctx->set_error(ctx,500,"###BUG### NULL response");
fcgi_write_response(globalctx, mapcache_core_respond_to_error(ctx));
goto cleanup;
}
#endif
fcgi_write_response(globalctx,http_response);
cleanup:
#ifdef USE_FASTCGI
apr_pool_destroy(ctx->pool);
ctx->clear_errors(ctx);
}
#endif
apr_pool_destroy(global_pool);
apr_terminate();
return 0;
}
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/cmake/ 0000775 0000000 0000000 00000000000 14653160677 0015214 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/cmake/FindAPACHE.cmake 0000664 0000000 0000000 00000001642 14653160677 0017743 0 ustar 00root root 0000000 0000000 #
# APACHE_FOUND - System has APACHE
# APACHE_INCLUDE_DIR - The APACHE include directory
#
# APACHE_LOCATION
# setting this enables search for apache libraries / headers in this location
#
# Include directories
#
find_path(APACHE_INCLUDE_DIR
NAMES httpd.h
PATH_SUFFIXES httpd apache apache2 apache22 apache24
)
if(NOT DEFINED APACHE_MODULE_DIR)
find_program(APXS_BIN NAMES apxs apxs2
PATH_SUFFIXES httpd apache apache2
)
if(APXS_BIN)
EXECUTE_PROCESS(COMMAND ${APXS_BIN} -q LIBEXECDIR
OUTPUT_VARIABLE APACHE_MODULE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
endif(APXS_BIN)
endif(NOT DEFINED APACHE_MODULE_DIR)
include(FindPackageHandleStandardArgs)
# handle the QUIETLY and REQUIRED arguments and set APACHE_FOUND to TRUE if
# all listed variables are TRUE
find_package_handle_standard_args(APACHE DEFAULT_MSG APACHE_INCLUDE_DIR )
mark_as_advanced(APACHE_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindAPR.cmake 0000664 0000000 0000000 00000004603 14653160677 0017444 0 ustar 00root root 0000000 0000000 # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# - Find Apache Portable Runtime
# Find the APR includes and libraries
# This module defines
# APR_INCLUDE_DIR and APRUTIL_INCLUDE_DIR, where to find apr.h, etc.
# APR_LIBRARIES and APRUTIL_LIBRARIES, the libraries needed to use APR.
# APR_FOUND and APRUTIL_FOUND, If false, do not try to use APR.
# also defined, but not for general use are
# APR_LIBRARY and APRUTIL_LIBRARY, where to find the APR library.
# APR first.
FIND_PROGRAM(APR_CONFIG_BIN
NAMES apr-config apr-1-config )
if(APR_CONFIG_BIN)
execute_process(
COMMAND ${APR_CONFIG_BIN} --includedir
OUTPUT_VARIABLE HINT_APR_INCLUDE_DIR
OUTPUT_STRIP_TRAILING_WHITESPACE
)
execute_process(
COMMAND ${APR_CONFIG_BIN} --cppflags
OUTPUT_VARIABLE APR_CPPFLAGS
OUTPUT_STRIP_TRAILING_WHITESPACE
)
endif(APR_CONFIG_BIN)
FIND_PATH(APR_INCLUDE_DIR
NAMES apr.h
HINTS ${HINT_APR_INCLUDE_DIR}
PATH_SUFFIXES apr-1 apr-1.0 apr
)
FIND_LIBRARY(APR_LIBRARY
NAMES apr-1 apr
PATH_SUFFIXES apr-1 apr-1.0 apr
)
set(APR_INCLUDE_DIRS ${APR_INCLUDE_DIR})
set(APR_LIBRARIES ${APR_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(APR DEFAULT_MSG APR_LIBRARY APR_INCLUDE_DIR)
mark_as_advanced(APR_LIBRARY APR_INCLUDE_DIR)
# Next, APRUTIL.
FIND_PATH(APU_INCLUDE_DIR
NAMES apu.h
PATH_SUFFIXES apr-1 apr-1.0 apr
)
FIND_LIBRARY(APU_LIBRARY
NAMES aprutil-1 aprutil
PATH_SUFFIXES apr-1 apr-1.0 apr
)
set(APU_INCLUDE_DIRS ${APU_INCLUDE_DIR})
set(APU_LIBRARIES ${APU_LIBRARY})
find_package_handle_standard_args(APU DEFAULT_MSG APU_LIBRARY APU_INCLUDE_DIR)
mark_as_advanced(APU_LIBRARY APU_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindBerkeleyDB.cmake 0000664 0000000 0000000 00000007105 14653160677 0020772 0 ustar 00root root 0000000 0000000 set(BERKELEYDB_FOUND TRUE)
# set the search path
if (WIN32)
file(GLOB BERKELEYDB_SEARCH_PATH "C:/Program Files/Oracle/Berkeley DB*")
if (NOT BERKELEYDB_SEARCH_PATH)
file(GLOB BERKELEYDB_SEARCH_PATH "C:/Program Files (x86)/Oracle/Berkeley DB*")
endif (NOT BERKELEYDB_SEARCH_PATH)
else (WIN32)
file(GLOB BERKELEYDB_SEARCH_PATH "/usr/local/BerkeleyDB*")
file(GLOB BERKELEYDB_INC_SEARCH_PATH "/usr/local/BerkeleyDB*/include")
file(GLOB BERKELEYDB_LIB_SEARCH_PATH "/usr/local/BerkeleyDB*/lib")
endif (WIN32)
# search for header
find_path(BERKELEYDB_INCLUDE_DIR
NAMES "db.h"
HINTS ${BERKELEYDB_SEARCH_PATH}
${BERKELEYDB_INC_SEARCH_PATH}
)
# header is found
if (BERKELEYDB_INCLUDE_DIR)
# retrieve version information from the header
file(READ "${BERKELEYDB_INCLUDE_DIR}/db.h" DB_H_FILE)
string(REGEX REPLACE ".*#define[ \t]+DB_VERSION_STRING[ \t]+\"([^\"]+)\".*" "\\1" BERKELEYDB_VERSION "${DB_H_FILE}")
string(REGEX REPLACE ".*#define[ \t]+DB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" BERKELEYDB_VERSION_MAJOR "${DB_H_FILE}")
string(REGEX REPLACE ".*#define[ \t]+DB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1" BERKELEYDB_VERSION_MINOR "${DB_H_FILE}")
string(REGEX REPLACE ".*#define[ \t]+DB_VERSION_PATCH[ \t]+([0-9]+).*" "\\1" BERKELEYDB_VERSION_PATCH "${DB_H_FILE}")
# search for library
if (WIN32)
file(GLOB BERKELEYDB_LIBRARIES
"${DBROOTDIR}/lib/libdb${BERKELEYDB_VERSION_MAJOR}${BERKELEYDB_VERSION_MINOR}.lib"
"${BERKELEYDB_SEARCH_PATH}/lib/libdb${BERKELEYDB_VERSION_MAJOR}${BERKELEYDB_VERSION_MINOR}.lib")
else (WIN32)
find_library(BERKELEYDB_LIBRARY
NAMES "db-${BERKELEYDB_VERSION_MAJOR}.${BERKELEYDB_VERSION_MINOR}" db
HINTS ${BERKELEYDB_SEARCH_PATH}
${BERKELEYDB_LIB_SEARCH_PATH}
)
endif (WIN32)
endif (BERKELEYDB_INCLUDE_DIR)
# header is not found
if (NOT BERKELEYDB_INCLUDE_DIR OR NOT BERKELEYDB_LIBRARY)
set(BERKELEYDB_FOUND_TMP FALSE)
else (NOT BERKELEYDB_INCLUDE_DIR OR NOT BERKELEYDB_LIBRARY)
set(BERKELEYDB_FOUND_TMP TRUE)
endif (NOT BERKELEYDB_INCLUDE_DIR OR NOT BERKELEYDB_LIBRARY)
# check found version
if (BERKELEYDB_FIND_VERSION AND BERKELEYDB_FOUND_TMP)
set(BERKELEYDB_FOUND_VERSION "${BERKELEYDB_VERSION_MAJOR}.${BERKELEYDB_VERSION_MINOR}.${BERKELEYDB_VERSION_PATCH}")
if (BERKELEYDB_FIND_VERSION_EXACT)
if (NOT ${BERKELEYDB_FOUND_VERSION} VERSION_EQUAL ${BERKELEYDB_FIND_VERSION})
set(BERKELEYDB_FOUND_TMP FALSE)
endif (NOT ${BERKELEYDB_FOUND_VERSION} VERSION_EQUAL ${BERKELEYDB_FIND_VERSION})
else (BERKELEYDB_FIND_VERSION_EXACT)
if (${BERKELEYDB_FOUND_VERSION} VERSION_LESS ${BERKELEYDB_FIND_VERSION})
set(BERKELEYDB_FOUND_TMP FALSE)
endif (${BERKELEYDB_FOUND_VERSION} VERSION_LESS ${BERKELEYDB_FIND_VERSION})
endif (BERKELEYDB_FIND_VERSION_EXACT)
if (NOT BERKELEYDB_FOUND_TMP)
message(SEND_ERROR "Berkeley DB library found, but with wrong version v${BERKELEYDB_FIND_VERSION} (${BERKELEYDB_FOUND_VERSION} was found)")
unset(BERKELEYDB_INCLUDE_DIR)
unset(BERKELEYDB_LIBRARY)
endif (NOT BERKELEYDB_FOUND_TMP)
endif (BERKELEYDB_FIND_VERSION AND BERKELEYDB_FOUND_TMP)
set(BERKELEYDB_INCLUDE_DIRS ${BERKELEYDB_INCLUDE_DIR})
set(BERKELEYDB_LIBRARIES ${BERKELEYDB_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(BerkeleyDB DEFAULT_MSG BERKELEYDB_LIBRARY BERKELEYDB_INCLUDE_DIR)
mark_as_advanced(BERKELEYDB_LIBRARY BERKELEYDB_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindFCGI.cmake 0000664 0000000 0000000 00000000600 14653160677 0017523 0 ustar 00root root 0000000 0000000 # Look for the header file.
find_path(FCGI_INCLUDE_DIR NAMES fastcgi.h)
# Look for the library.
find_library(FCGI_LIBRARY NAMES fcgi)
set(FCGI_INCLUDE_DIRS ${FCGI_INCLUDE_DIR})
set(FCGI_LIBRARIES ${FCGI_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(FCGI DEFAULT_MSG FCGI_LIBRARY FCGI_INCLUDE_DIR)
mark_as_advanced(FCGI_LIBRARY FCGI_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindGDAL.cmake 0000664 0000000 0000000 00000006270 14653160677 0017533 0 ustar 00root root 0000000 0000000 # Locate gdal
#
# This module accepts the following environment variables:
#
# GDAL_DIR or GDAL_ROOT - Specify the location of GDAL
#
# This module defines the following CMake variables:
#
# GDAL_FOUND - True if libgdal is found
# GDAL_LIBRARY - A variable pointing to the GDAL library
# GDAL_INCLUDE_DIR - Where to find the headers
#=============================================================================
# Copyright 2007-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
#
# $GDALDIR is an environment variable that would
# correspond to the ./configure --prefix=$GDAL_DIR
# used in building gdal.
#
# Created by Eric Wing. I'm not a gdal user, but OpenSceneGraph uses it
# for osgTerrain so I whipped this module together for completeness.
# I actually don't know the conventions or where files are typically
# placed in distros.
# Any real gdal users are encouraged to correct this (but please don't
# break the OS X framework stuff when doing so which is what usually seems
# to happen).
# This makes the presumption that you are include gdal.h like
#
#include "gdal.h"
find_path(GDAL_INCLUDE_DIR gdal.h
HINTS
ENV GDAL_DIR
ENV GDAL_ROOT
PATH_SUFFIXES
gdal
GDAL
gdal1
PATHS
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
if(UNIX)
# Use gdal-config to obtain the library version (this should hopefully
# allow us to -lgdal1.x.y where x.y are correct version)
# For some reason, libgdal development packages do not contain
# libgdal.so...
find_program(GDAL_CONFIG gdal-config
HINTS
ENV GDAL_DIR
ENV GDAL_ROOT
PATH_SUFFIXES bin
PATHS
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
if(GDAL_CONFIG)
execute_process(COMMAND ${GDAL_CONFIG} --libs OUTPUT_VARIABLE GDAL_CONFIG_LIBS)
if(GDAL_CONFIG_LIBS)
string(REGEX MATCHALL "-l[^ ]+" _gdal_dashl ${GDAL_CONFIG_LIBS})
string(REGEX REPLACE "-l" "" _gdal_lib "${_gdal_dashl}")
string(REGEX MATCHALL "-L[^ ]+" _gdal_dashL ${GDAL_CONFIG_LIBS})
string(REGEX REPLACE "-L" "" _gdal_libpath "${_gdal_dashL}")
endif()
endif()
endif()
find_library(GDAL_LIBRARY
NAMES ${_gdal_lib} gdal gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL
HINTS
ENV GDAL_DIR
ENV GDAL_ROOT
${_gdal_libpath}
PATH_SUFFIXES lib
PATHS
/sw
/opt/local
/opt/csw
/opt
/usr/freeware
)
set(GDAL_LIBRARIES ${GDAL_LIBRARY})
set(GDAL_INCLUDE_DIRS ${GDAL_INCLUDE_DIR})
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GDAL DEFAULT_MSG GDAL_LIBRARY GDAL_INCLUDE_DIR)
MARK_AS_ADVANCED(GDAL_LIBRARY GDAL_INCLUDE_DIR GDAL_CONFIG)
mapcache-rel-1-14-1/cmake/FindGEOS.cmake 0000664 0000000 0000000 00000001650 14653160677 0017556 0 ustar 00root root 0000000 0000000 # Find the native GEOS(Geometry Engine - Open Source) includes and libraries.
#
# This module defines:
#
# GEOS_INCLUDE_DIR, where to find geos.h, etc.
# GEOS_LIBRARY, libraries to link against to use GEOS, using the geos_c library
# GEOS_FOUND, True if found, false if one of the above are not found.
#---
# Find include path:
# Note: Version < 3.3.0 do not have geos.h in the geos sub directory; hence,
# the check for both "geos/geos.h" and "geos.h".
#---
find_path( GEOS_INCLUDE_DIR
NAMES geos_c.h
PATH_SUFFIXES geos)
# Find GEOS C library:
find_library( GEOS_LIBRARY NAMES geos_c )
set(GEOS_INCLUDE_DIRS ${GEOS_INCLUDE_DIR})
set(GEOS_LIBRARIES ${GEOS_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args( GEOS DEFAULT_MSG
GEOS_LIBRARY
GEOS_INCLUDE_DIR )
MARK_AS_ADVANCED(GEOS_LIBRARY GEOS_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindGEOTIFF.cmake 0000664 0000000 0000000 00000000675 14653160677 0020112 0 ustar 00root root 0000000 0000000 find_path(GEOTIFF_INCLUDE_DIR
NAMES geotiff.h
PATH_SUFFIXES libgeotiff geotiff)
find_library(GEOTIFF_LIBRARY
NAMES geotiff geotiff3
PATH_SUFFIXES geotiff )
set(GEOTIFF_INCLUDE_DIRS ${GEOTIFF_INCLUDE_DIR})
set(GEOTIFF_LIBRARIES ${GEOTIFF_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GEOTIFF DEFAULT_MSG GEOTIFF_LIBRARY GEOTIFF_INCLUDE_DIR)
mark_as_advanced(GEOTIFF_LIBRARY GEOTIFF_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindLMDB.cmake 0000664 0000000 0000000 00000000756 14653160677 0017545 0 ustar 00root root 0000000 0000000 set(LMDB_FOUND TRUE)
set(LMDB_INC_SEARCH_PATH "/usr/include")
set(LMDB_LIB_SEARCH_PATH "/usr/lib")
find_path(LMDB_INCLUDE_DIR NAMES "lmdb.h" HINTS ${LMDB_INC_SEARCH_PATH})
find_library(LMDB_LIBRARY NAMES "lmdb" HINTS ${LMDB_LIB_SEARCH_PATH})
set(LMDB_INCLUDE_DIRS ${LMDB_INCLUDE_DIR})
set(LMDB_LIBRARIES ${LMDB_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(LMDB DEFAULT_MSG LMDB_LIBRARY LMDB_INCLUDE_DIR)
mark_as_advanced(LMDB_LIBRARY LMDB_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindMAPSERVER.cmake 0000664 0000000 0000000 00000000661 14653160677 0020366 0 ustar 00root root 0000000 0000000
FIND_PATH(MAPSERVER_INCLUDE_DIR
NAMES mapserver.h
PATH_SUFFIXES mapserver
)
FIND_LIBRARY(MAPSERVER_LIBRARY
NAMES mapserver
)
set(MAPSERVER_INCLUDE_DIRS ${MAPSERVER_INCLUDE_DIR})
set(MAPSERVER_LIBRARIES ${MAPSERVER_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(MAPSERVER DEFAULT_MSG MAPSERVER_LIBRARY MAPSERVER_INCLUDE_DIR)
mark_as_advanced(MAPSERVER_LIBRARY MAPSERVER_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindPCRE.cmake 0000664 0000000 0000000 00000000532 14653160677 0017550 0 ustar 00root root 0000000 0000000
FIND_PATH(PCRE_INCLUDE_DIR
NAMES pcre.h
)
FIND_LIBRARY(PCRE_LIBRARY
NAMES pcre pcred
)
set(PCRE_INCLUDE_DIRS ${PCRE_INCLUDE_DIR})
set(PCRE_LIBRARIES ${PCRE_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PCRE DEFAULT_MSG PCRE_LIBRARY PCRE_INCLUDE_DIR)
mark_as_advanced(PCRE_LIBRARY PCRE_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindPCRE2.cmake 0000664 0000000 0000000 00000002154 14653160677 0017634 0 ustar 00root root 0000000 0000000 # Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file COPYING-CMAKE-SCRIPTS or https://cmake.org/licensing for details.
#.rst
# FindPCRE2
# ~~~~~~~~~
# Copyright (C) 2017-2018, Hiroshi Miura
#
# Find the native PCRE2 headers and libraries.
find_path(PCRE2_INCLUDE_DIR NAMES pcre2.h)
find_library(PCRE2-8_LIBRARY NAMES pcre2-8 pcre2-8d pcre2-8-static pcre2-8-staticd NAMES_PER_DIR)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PCRE2
REQUIRED_VARS PCRE2-8_LIBRARY PCRE2_INCLUDE_DIR)
mark_as_advanced(PCRE2_INCLUDE_DIR PCRE2-8_LIBRARY)
if(PCRE2_FOUND)
list(APPEND PCRE2_LIBRARIES "${PCRE2-8_LIBRARY}")
set(PCRE2_INCLUDE_DIRS "${PCRE2_INCLUDE_DIR}")
if(NOT TARGET PCRE2::PCRE2-8)
add_library(PCRE2::PCRE2-8 UNKNOWN IMPORTED)
set_target_properties(PCRE2::PCRE2-8 PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${PCRE2_INCLUDE_DIR}"
IMPORTED_LINK_INTERFACE_LANGUAGES "C"
IMPORTED_LOCATION "${PCRE2-8_LIBRARY}")
endif()
endif()
mapcache-rel-1-14-1/cmake/FindPixman.cmake 0000664 0000000 0000000 00000001272 14653160677 0020255 0 ustar 00root root 0000000 0000000 FIND_PACKAGE(PkgConfig)
PKG_CHECK_MODULES(PC_PIXMAN pixman)
if(NOT PC_PIXMAN_FOUND)
PKG_CHECK_MODULES(PC_PIXMAN pixman-1)
endif(NOT PC_PIXMAN_FOUND)
FIND_PATH(PIXMAN_INCLUDE_DIR
NAMES pixman.h
HINTS ${PC_PIXMAN_INCLUDEDIR}
${PC_PIXMAN_INCLUDE_DIR}
PATH_SUFFIXES pixman pixman-1
)
FIND_LIBRARY(PIXMAN_LIBRARY
NAMES pixman pixman-1
HINTS ${PC_PIXMAN_LIBDIR}
${PC_PIXMAN_LIBRARY_DIRS}
)
set(PIXMAN_INCLUDE_DIRS ${PIXMAN_INCLUDE_DIR})
set(PIXMAN_LIBRARIES ${PIXMAN_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Pixman DEFAULT_MSG PIXMAN_LIBRARY PIXMAN_INCLUDE_DIR)
mark_as_advanced(PIXMAN_LIBRARY PIXMAN_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindRIAK.cmake 0000664 0000000 0000000 00000000526 14653160677 0017550 0 ustar 00root root 0000000 0000000
FIND_PATH(RIAK_INCLUDE_DIR
NAMES riack.h
)
FIND_LIBRARY(RIAK_LIBRARY
NAMES riack
)
set(RIAK_INCLUDE_DIRS ${RIAK_INCLUDE_DIR})
set(RIAK_LIBRARIES ${RIAK_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(RIAK DEFAULT_MSG RIAK_LIBRARY RIAK_INCLUDE_DIR)
mark_as_advanced(RIAK_LIBRARY RIAK_INCLUDE_DIR)
mapcache-rel-1-14-1/cmake/FindRedis.cmake 0000664 0000000 0000000 00000001572 14653160677 0020072 0 ustar 00root root 0000000 0000000 IF (HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
SET (HIREDIS_FOUND TRUE)
ELSE(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
FIND_PATH(HIREDIS_INCLUDE_DIR hiredis/hiredis.h
/usr/include/
/usr/include/hiredis
/usr/local/include/
/usr/local/include/hiredis
/opt/local/include/
/opt/local/include/hiredis
)
FIND_LIBRARY(HIREDIS_LIBRARIES NAMES hiredis libhiredis
PATHS
/usr/lib
/usr/local/lib
/opt/local/lib
)
IF(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
SET(HIREDIS_FOUND TRUE)
MESSAGE(STATUS "Found hiredis: ${HIREDIS_INCLUDE_DIR}, ${HIREDIS_LIBRARIES}")
ELSE(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
SET(HIREDIS_FOUND FALSE)
MESSAGE(STATUS "hiredis client library not found.")
ENDIF(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
MARK_AS_ADVANCED(HIREDIS_INCLUDE_DIR HIREDIS_LIBRARIES)
ENDIF(HIREDIS_INCLUDE_DIR AND HIREDIS_LIBRARIES)
mapcache-rel-1-14-1/cmake/FindSQLITE.cmake 0000664 0000000 0000000 00000000633 14653160677 0020022 0 ustar 00root root 0000000 0000000
FIND_PATH(SQLITE_INCLUDE_DIR
NAMES sqlite3.h
PATH_SUFFIXES sqlite sqlite3
)
FIND_LIBRARY(SQLITE_LIBRARY
NAMES sqlite3 sqlite3_i
)
set(SQLITE_INCLUDE_DIRS ${SQLITE_INCLUDE_DIR})
set(SQLITE_LIBRARIES ${SQLITE_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(SQLITE DEFAULT_MSG SQLITE_LIBRARY SQLITE_INCLUDE_DIR)
mark_as_advanced(SQLITE_LIBRARY SQLITE_INCLUDE_DIR)
mapcache-rel-1-14-1/contrib/ 0000775 0000000 0000000 00000000000 14653160677 0015574 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/contrib/mapcache_detail/ 0000775 0000000 0000000 00000000000 14653160677 0020657 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/contrib/mapcache_detail/CMakeLists.txt 0000664 0000000 0000000 00000003440 14653160677 0023420 0 ustar 00root root 0000000 0000000 option(WITH_GEOS
"Choose if GEOS geometry operations support should be built in" ON)
option(WITH_OGR
"Choose if OGR/GDAL input vector support should be built in" ON)
add_executable(mapcache_detail mapcache_detail.c)
target_link_libraries(mapcache_detail mapcache)
if (WITH_SQLITE)
find_package(SQLITE)
if(SQLITE_FOUND)
include_directories(${SQLITE_INCLUDE_DIR})
target_link_libraries(mapcache_detail ${SQLITE_LIBRARY})
else(SQLITE_FOUND)
report_mandatory_not_found(SQLITE)
endif(SQLITE_FOUND)
else (WITH_SQLITE)
report_dependency_error(MAPCACHE_DETAIL SQLITE)
endif (WITH_SQLITE)
if (WITH_OGR)
find_package(GDAL)
if (GDAL_FOUND)
include_directories(${GDAL_INCLUDE_DIR})
target_link_libraries(mapcache_detail ${GDAL_LIBRARY})
set (USE_OGR 1)
else (GDAL_FOUND)
report_optional_not_found(GDAL)
endif (GDAL_FOUND)
endif (WITH_OGR)
if (WITH_GEOS)
find_package(GEOS)
if (GEOS_FOUND)
include_directories(${GEOS_INCLUDE_DIR})
target_link_libraries(mapcache_detail ${GEOS_LIBRARY})
set (USE_GEOS 1)
else (GEOS_FOUND)
report_optional_not_found(GEOS)
endif (GEOS_FOUND)
endif (WITH_GEOS)
set (CURRENT_BINARY_DIR "${PROJECT_BINARY_DIR}/contrib/mapcache_detail/")
include_directories("${CURRENT_BINARY_DIR}")
configure_file (
"${CMAKE_CURRENT_SOURCE_DIR}/mapcache_detail_config.h.in"
"${CURRENT_BINARY_DIR}/mapcache_detail_config.h"
)
message(STATUS "* mapcache_detail Configuration Options:")
message(STATUS " * Mandatory components")
message(STATUS " * SQLite: ${SQLITE_LIBRARY}")
message(STATUS " * Optional components")
status_optional_component("GEOS" "${USE_GEOS}" "${GEOS_LIBRARY}")
status_optional_component("OGR" "${USE_OGR}" "${GDAL_LIBRARY}")
INSTALL(TARGETS mapcache_detail
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
mapcache-rel-1-14-1/contrib/mapcache_detail/mapcache_detail.c 0000664 0000000 0000000 00000174222 14653160677 0024116 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache utility program for preparing cache export
* Author: Jerome Boue and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache_detail_config.h"
#if defined(USE_OGR) && defined(USE_GEOS)
#define USE_CLIPPERS
#endif
#include
#include
#include
#include
#include
#ifndef _WIN32
#include
#endif
#include
#include
#include
#include
#include
#include "mapcache.h"
#include "ezxml.h"
#include "cJSON.h"
#if defined(_WIN32) && !defined(__CYGWIN__)
#include
#else
#include
#endif
#ifdef USE_CLIPPERS
#include
#include
#include
#include
#endif // USE_CLIPPERS
///////////////////////////////////////////////////////////////////////////////
//
// Command Line Interface
//
///////////////////////////////////////////////////////////////////////////////
// List of command line options
const apr_getopt_option_t optlist[] = {
{ "help", 'h', FALSE, "Display this message and exit" },
{ "config", 'c', TRUE, "Configuration file"
" (/path/to/mapcache.xml)" },
{ "dimension", 'D', TRUE, "Set the value of a dimension: format"
" DIMENSIONNAME=VALUE. Can be used"
" multiple times for multiple"
" dimensions" },
{ "tileset", 't', TRUE, "Tileset to analyze" },
{ "grid", 'g', TRUE, "Grid to analyze" },
{ "extent", 'e', TRUE, "Extent to analyze:"
"format minx,miny,maxx,maxy. Cannot be"
" used with --ogr-datasource." },
#ifdef USE_CLIPPERS
{ "ogr-datasource", 'd', TRUE, "OGR data source to get features from."
" Cannot be used with --extent." },
{ "ogr-layer", 'l', TRUE, "OGR layer inside OGR data source. Cannot"
" be used with --ogr-sql." },
{ "ogr-where", 'w', TRUE, "Filter to apply on OGR layer features."
" Cannot be used with --ogr-sql." },
{ "ogr-sql", 's', TRUE, "SQL query to filter inside OGR data"
" source. Cannot be used with"
" --ogr-layer or --ogr-where." },
#endif // USE_CLIPPERS
{ "zoom", 'z', TRUE, "Set min and max zoom levels to analyze,"
" separated by a comma, eg: 12,15" },
{ "query", 'q', TRUE, "Set query for counting tiles in a"
" rectangle. Default value works with"
" default schema of SQLite caches." },
{ "short-output", 'o', FALSE, "Only existing SQLite files are reported,"
" missing SQLite files are still taken"
" into account for level and global"
" coverage." },
{ "endofopt", 0, FALSE, "End of options" }
};
// Extract basename from a path
const char * base_name(const char * path)
{
const char *subdir, *basename=path;
for (subdir=path ; (subdir=strchr(subdir, '/')) ; basename=++subdir);
return basename;
}
// Get terminal columns
int termcols()
{
#if defined(_WIN32) && !defined(__CYGWIN__)
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),&csbi)) csbi.dwSize.X = 0;
return csbi.dwSize.X;
#else
struct winsize w;
if (ioctl(STDERR_FILENO, TIOCGWINSZ, &w) < 0) w.ws_col = 0;
return w.ws_col;
#endif
}
// Display help message
void usage(apr_pool_t * pool, const char * path, char * msg, ...)
{
int i;
const char * name = base_name(path);
if (msg) {
va_list args;
va_start(args, msg);
fprintf(stderr, "Error: %s: ", name);
vfprintf(stderr, msg, args);
fprintf(stderr, "\n\n");
va_end(args);
}
fprintf(stderr, "\nUsage: %s \n\n", name);
for (i=0 ; optlist[i].optch ; i++)
{
char ** words;
int linewidth = 16;
const int cols = termcols();
fprintf(stderr, " -%c | --%s%s\n ",
optlist[i].optch, optlist[i].name,
optlist[i].has_arg ? " " : "");
apr_tokenize_to_argv(optlist[i].description, &words, pool);
for (;*words;words++) {
linewidth += strlen(*words)+1;
if (cols > 0 && linewidth > cols) {
fprintf(stderr, "\n ");
linewidth = 16 + strlen(*words)+1;
}
fprintf(stderr, "%s ", *words);
}
fprintf(stderr, "\n");
}
}
///////////////////////////////////////////////////////////////////////////////
//
// Hooks for support libraries
//
///////////////////////////////////////////////////////////////////////////////
#ifdef USE_CLIPPERS
// GEOS notice function
void notice(const char *fmt,...)
{
va_list ap;
fprintf(stdout,"{ notice: ");
va_start(ap,fmt);
vfprintf(stdout,fmt,ap);
va_end(ap);
fprintf(stdout," }\n");
}
// GEOS log_and_exit function
void log_and_exit(const char *fmt,...)
{
va_list ap;
fprintf(stderr,"{ error: ");
va_start(ap,fmt);
vfprintf(stderr,fmt,ap);
va_end(ap);
fprintf(stderr," }\n");
exit(1);
}
#endif // USE_CLIPPERS
// Mapcache log function
void mapcache_log(mapcache_context *ctx, mapcache_log_level lvl, char *msg, ...)
{
va_list args;
va_start(args, msg);
vfprintf(stderr, msg, args);
va_end(args);
fprintf(stderr, "\n");
}
// cJSON memory allocation Hook on APR pool mechanism
static apr_pool_t * _pool_for_cJSON_malloc_hook;
static void * _malloc_for_cJSON(size_t size) {
return apr_palloc(_pool_for_cJSON_malloc_hook,size);
}
static void _free_for_cJSON(void *ptr) { }
static void _create_json_pool(apr_pool_t * parent_pool) {
cJSON_Hooks hooks = { _malloc_for_cJSON, _free_for_cJSON };
apr_pool_create(&_pool_for_cJSON_malloc_hook,parent_pool);
cJSON_InitHooks(&hooks);
}
static void _destroy_json_pool() {
apr_pool_destroy(_pool_for_cJSON_malloc_hook);
}
///////////////////////////////////////////////////////////////////////////////
//
// Conversions between various geometry formats
//
///////////////////////////////////////////////////////////////////////////////
#ifdef USE_CLIPPERS
// Convert `mapcache_extent` to `GEOSGeometry` polygon
GEOSGeometry * mapcache_extent_to_GEOSGeometry(const mapcache_extent *extent)
{
GEOSCoordSequence *cs = GEOSCoordSeq_create(5,2);
GEOSGeometry *lr = GEOSGeom_createLinearRing(cs);
GEOSGeometry *bb = GEOSGeom_createPolygon(lr,NULL,0);
GEOSCoordSeq_setX(cs,0,extent->minx);
GEOSCoordSeq_setY(cs,0,extent->miny);
GEOSCoordSeq_setX(cs,1,extent->maxx);
GEOSCoordSeq_setY(cs,1,extent->miny);
GEOSCoordSeq_setX(cs,2,extent->maxx);
GEOSCoordSeq_setY(cs,2,extent->maxy);
GEOSCoordSeq_setX(cs,3,extent->minx);
GEOSCoordSeq_setY(cs,3,extent->maxy);
GEOSCoordSeq_setX(cs,4,extent->minx);
GEOSCoordSeq_setY(cs,4,extent->miny);
return bb;
}
// Update `GEOSGeometry` polygon created with
// `mapcache_extent_to_GEOSGeometry()` with values from another
// `mapcache_extent`
void update_GEOSGeometry_with_mapcache_extent(GEOSGeometry *bb,
const mapcache_extent *extent)
{
GEOSGeometry *lr = (GEOSGeometry *)GEOSGetExteriorRing(bb);
GEOSCoordSequence *cs = (GEOSCoordSequence *)GEOSGeom_getCoordSeq(lr);
GEOSCoordSeq_setX(cs,0,extent->minx);
GEOSCoordSeq_setY(cs,0,extent->miny);
GEOSCoordSeq_setX(cs,1,extent->maxx);
GEOSCoordSeq_setY(cs,1,extent->miny);
GEOSCoordSeq_setX(cs,2,extent->maxx);
GEOSCoordSeq_setY(cs,2,extent->maxy);
GEOSCoordSeq_setX(cs,3,extent->minx);
GEOSCoordSeq_setY(cs,3,extent->maxy);
GEOSCoordSeq_setX(cs,4,extent->minx);
GEOSCoordSeq_setY(cs,4,extent->miny);
}
// Convert `GEOSGeometry` to GeoJSON string
char * GEOSGeometry_to_GeoJSON(const GEOSGeometry *g)
{
OGRGeometryH geom;
GEOSWKTWriter * wr = GEOSWKTWriter_create();
char * wkt = GEOSWKTWriter_write(wr,g);
char * geojson = NULL;
OGR_G_CreateFromWkt(&wkt,NULL,&geom);
geojson = OGR_G_ExportToJson(geom);
OGR_G_DestroyGeometry(geom);
GEOSWKTWriter_destroy(wr);
return geojson;
}
// Convert `GEOSGeometry` to `cJSON` structure embedding GeoJSON data
cJSON * GEOSGeometry_to_cJSON(const GEOSGeometry *g)
{
char * geojson = GEOSGeometry_to_GeoJSON(g);
cJSON * jgeom = cJSON_Parse(geojson);
CPLFree(geojson);
return jgeom;
}
// Convert `mapcache_extent` to GeoJSON string
char * mapcache_extent_to_GeoJSON(const mapcache_extent *extent)
{
return GEOSGeometry_to_GeoJSON(mapcache_extent_to_GEOSGeometry(extent));
}
// Convert `mapcache_extent` to `cJSON` structure embedding GeoJSON data
cJSON * mapcache_extent_to_cJSON(const mapcache_extent *extent)
{
return GEOSGeometry_to_cJSON(mapcache_extent_to_GEOSGeometry(extent));
}
// Convert `OGRLayerH` to `cJSON` structure embedding GeoJSON data
cJSON * OGRLayerH_to_cJSON(const OGRLayerH layer)
{
cJSON *jlayer, *jfeatures, *jfeature, *jgeom;
OGRFeatureH feature;
int nfeat = 0;
jlayer = cJSON_CreateObject();
cJSON_AddStringToObject(jlayer, "type", "FeatureCollection");
jfeatures = cJSON_AddArrayToObject(jlayer, "features");
OGR_L_ResetReading(layer);
while ((feature = OGR_L_GetNextFeature(layer))) {
OGRGeometryH ogr_geom = OGR_F_GetGeometryRef(feature);
char * geojson = OGR_G_ExportToJson(ogr_geom);
jgeom = cJSON_Parse(geojson);
CPLFree(geojson);
jfeature = cJSON_CreateObject();
cJSON_AddItemToObject(jfeatures, "", jfeature);
cJSON_AddStringToObject(jfeature, "type", "Feature");
cJSON_AddItemToObject(jfeature, "geometry", jgeom);
nfeat++;
}
if (nfeat == 1) {
return jgeom;
} else {
return jlayer;
}
}
#else
// Convert `mapcache_extent` to `cJSON` structure embedding GeoJSON data
cJSON * mapcache_extent_to_cJSON(const mapcache_extent *extent)
{
cJSON * geojson = cJSON_CreateObject();
cJSON * jpolygon;
cJSON * jpoint;
cJSON_AddStringToObject(geojson, "type", "Polygon");
jpolygon = cJSON_AddArrayToObject(geojson, "coordinates");
jpoint = cJSON_AddArrayToObject(jpolygon, "");
cJSON_AddNumberToObject(jpoint, "", extent->minx);
cJSON_AddNumberToObject(jpoint, "", extent->miny);
jpoint = cJSON_CreateObject();
jpoint = cJSON_AddArrayToObject(jpolygon, "");
cJSON_AddNumberToObject(jpoint, "", extent->maxx);
cJSON_AddNumberToObject(jpoint, "", extent->miny);
jpoint = cJSON_CreateObject();
jpoint = cJSON_AddArrayToObject(jpolygon, "");
cJSON_AddNumberToObject(jpoint, "", extent->maxx);
cJSON_AddNumberToObject(jpoint, "", extent->maxy);
jpoint = cJSON_CreateObject();
jpoint = cJSON_AddArrayToObject(jpolygon, "");
cJSON_AddNumberToObject(jpoint, "", extent->minx);
cJSON_AddNumberToObject(jpoint, "", extent->maxy);
jpoint = cJSON_CreateObject();
jpoint = cJSON_AddArrayToObject(jpolygon, "");
cJSON_AddNumberToObject(jpoint, "", extent->minx);
cJSON_AddNumberToObject(jpoint, "", extent->miny);
return geojson;
}
#endif // USE_CLIPPERS
///////////////////////////////////////////////////////////////////////////////
//
// Operations on Mapcache SQLite files
//
///////////////////////////////////////////////////////////////////////////////
// Replace all occurrences of substr in string
char * str_replace_all(apr_pool_t *pool, const char *string,
const char *substr, const char *replacement)
{
char * replaced = apr_pstrdup(pool, string);
while (strstr(replaced, substr)) {
replaced = mapcache_util_str_replace(pool, string, substr, replacement);
}
return replaced;
}
// Build up actual SQLite filename from dbfile template
char * dbfilename(apr_pool_t * pool, char * template,
mapcache_tileset * tileset, mapcache_grid * grid,
apr_array_header_t * dimensions, apr_hash_t * fmt, int z,
int dbx, int dby, int xcount, int ycount, int top)
{
int tilx = dbx * xcount;
int tily = dby * ycount;
char * path = apr_pstrdup(pool, template);
if (!strstr(path, "{")) {
return path;
}
// Tileset and grid
path = str_replace_all(pool, path, "{tileset}", tileset->name);
path = str_replace_all(pool, path, "{grid}", grid->name);
// Dimensions: both {dim} and {dim:foo}
if (strstr(path, "{dim") && dimensions) {
char * dimstr = "";
int i = dimensions->nelts;
while(i--) {
mapcache_requested_dimension *entry;
const char * val;
char *solodim;
entry = APR_ARRAY_IDX(dimensions, i, mapcache_requested_dimension*);
val = mapcache_util_str_sanitize(pool, entry->cached_value, "/.", '#');
solodim = apr_pstrcat(pool, "{dim:", entry->dimension->name, "}", NULL);
dimstr = apr_pstrcat(pool, dimstr, "#", val, NULL);
if(strstr(path, solodim)) {
path = str_replace_all(pool, path, solodim, val);
}
}
path = str_replace_all(pool, path, "{dim}", dimstr);
}
// Zoom level
path = str_replace_all(pool, path, "{z}",
apr_psprintf(pool, apr_hash_get(fmt, "z", APR_HASH_KEY_STRING), z));
// X coordinate
if (xcount > 0) {
char * curfmt;
curfmt = apr_hash_get(fmt, "x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{x}",
apr_psprintf(pool, curfmt, tilx));
curfmt = apr_hash_get(fmt, "div_x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{div_x}",
apr_psprintf(pool, curfmt, dbx));
curfmt = apr_hash_get(fmt, "inv_x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_x}",
apr_psprintf(pool, curfmt, tilx));
curfmt = apr_hash_get(fmt, "inv_div_x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_div_x}",
apr_psprintf(pool, curfmt, dbx));
}
// Y coordinate
if (ycount > 0) {
char * curfmt;
curfmt = apr_hash_get(fmt, "y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{y}",
apr_psprintf(pool, curfmt, tily));
curfmt = apr_hash_get(fmt, "div_y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{div_y}",
apr_psprintf(pool, curfmt, dby));
curfmt = apr_hash_get(fmt, "inv_y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_y}",
apr_psprintf(pool, curfmt, tily));
curfmt = apr_hash_get(fmt, "inv_div_y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_div_y}",
apr_psprintf(pool, curfmt, dby));
}
// Z top
if (top > 0) {
char * curfmt;
curfmt = apr_hash_get(fmt, "top", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{top}",
apr_psprintf(pool, curfmt, top));
curfmt = apr_hash_get(fmt, "top_x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{top_x}",
apr_psprintf(pool, curfmt, dbx));
curfmt = apr_hash_get(fmt, "inv_top_x", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_top_x}",
apr_psprintf(pool, curfmt, dbx));
curfmt = apr_hash_get(fmt, "top_y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{top_y}",
apr_psprintf(pool, curfmt, dby));
curfmt = apr_hash_get(fmt, "inv_top_y", APR_HASH_KEY_STRING);
path = str_replace_all(pool, path, "{inv_top_y}",
apr_psprintf(pool, curfmt, dby));
}
return path;
}
// Query SQLite for getting tile count in specified area
void count_tiles_in_rectangle(
mapcache_context * ctx,
int z,
mapcache_extent_i til,
mapcache_tileset * tileset,
mapcache_grid_link * grid_link,
apr_array_header_t * dimensions,
const char * dbfile,
const char * count_query,
int *tmax,
int *tcached
)
{
mapcache_grid *grid = grid_link->grid;
sqlite3 * db;
sqlite3_stmt * res;
int rc, idx;
int count;
*tcached = 0;
*tmax = (til.maxx-til.minx+1) * (til.maxy-til.miny+1);
rc = sqlite3_open_v2(dbfile, &db, SQLITE_OPEN_READONLY, NULL);
if (rc != SQLITE_OK) {
sqlite3_close(db);
return;
}
sqlite3_busy_timeout(db, 5000);
rc = sqlite3_prepare_v2(db, count_query, -1, &res, 0);
if (rc != SQLITE_OK) {
ctx->set_error(ctx, 500, "SQLite failed on %s: '%s'",
dbfile, sqlite3_errmsg(db));
sqlite3_close(db);
return;
}
idx = sqlite3_bind_parameter_index(res, ":minx");
if (idx) sqlite3_bind_int(res, idx, til.minx);
idx = sqlite3_bind_parameter_index(res, ":miny");
if (idx) sqlite3_bind_int(res, idx, til.miny);
idx = sqlite3_bind_parameter_index(res, ":maxx");
if (idx) sqlite3_bind_int(res, idx, til.maxx);
idx = sqlite3_bind_parameter_index(res, ":maxy");
if (idx) sqlite3_bind_int(res, idx, til.maxy);
idx = sqlite3_bind_parameter_index(res, ":z");
if (idx) sqlite3_bind_int(res, idx, z);
idx = sqlite3_bind_parameter_index(res, ":grid");
if (idx) sqlite3_bind_text(res, idx, grid->name, -1, SQLITE_STATIC);
idx = sqlite3_bind_parameter_index(res, ":tileset");
if (idx) sqlite3_bind_text(res, idx, tileset->name, -1, SQLITE_STATIC);
idx = sqlite3_bind_parameter_index(res, ":dim");
if (idx) {
char * dim = "";
if (dimensions) {
mapcache_tile tile;
tile.dimensions = dimensions;
dim = mapcache_util_get_tile_dimkey(ctx, &tile, NULL, NULL);
}
sqlite3_bind_text(res, idx, dim, -1, SQLITE_STATIC);
}
rc = sqlite3_step(res);
switch (rc) {
case SQLITE_ROW:
count = strtol((const char*)sqlite3_column_text(res, 0), NULL, 10);
break;
case SQLITE_DONE:
ctx->set_error(ctx, 500, "SQLite returned no tile count (%s)", dbfile);
count = 0;
break;
default:
ctx->set_error(ctx, 500, "SQLite failed on %s: '%s'",
dbfile, sqlite3_errmsg(db));
count = 0;
}
sqlite3_finalize(res);
sqlite3_close(db);
*tcached = count;
}
#ifdef USE_CLIPPERS
// Count tiles in arbitrary region geometry for given zoom level, iterating
// over supplied bounding box expressed in tiles
void count_tiles_in_region(
mapcache_context *c,
int zl,
mapcache_extent_i til_bbox,
mapcache_tileset *t,
mapcache_grid_link *gl,
apr_array_header_t *d,
const GEOSPreparedGeometry *pg,
int file_exists,
int *tmax,
int *tcached
)
{
int tx, ty;
GEOSGeometry *tile_geom = NULL;
// Iterate over tiles within supplied bbox
*tmax = *tcached = 0;
for (tx = til_bbox.minx ; tx <= til_bbox.maxx ; tx++) {
for (ty = til_bbox.miny ; ty <= til_bbox.maxy ; ty++) {
mapcache_extent tile_bbox;
// Compute tile bounding box expressed in grid units
mapcache_grid_get_tile_extent(c, gl->grid, tx, ty, zl, &tile_bbox);
if (!tile_geom) {
tile_geom = mapcache_extent_to_GEOSGeometry(&tile_bbox);
} else {
update_GEOSGeometry_with_mapcache_extent(tile_geom, &tile_bbox);
}
// Count tile if it is within region of interest
if (GEOSPreparedIntersects(pg, tile_geom) == 1) {
int tile_exists = FALSE;
mapcache_tile *tile;
(*tmax)++;
// Check whether tile is present in cache
if (file_exists) {
tile = mapcache_tileset_tile_create(c->pool, t, gl);
tile->x = tx;
tile->y = ty;
tile->z = zl;
tile->dimensions = d;
tile_exists = mapcache_cache_tile_exists(c, t->_cache, tile);
if (tile_exists) (*tcached)++;
}
}
}
}
GEOSGeom_destroy(tile_geom);
}
#endif // USE_CLIPPERS
///////////////////////////////////////////////////////////////////////////////
//
// Program entry point
//
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char * argv[])
{
mapcache_context ctx;
apr_getopt_t * opt;
int status;
int optk;
const char * optv;
int json_output = TRUE;
int show_progress = TRUE;
cJSON *jreport, *jitem, *jregion, *jzooms, *jzoom, *jfiles, *jfile;
const char * config_file = NULL;
const char * tileset_name = NULL;
const char * grid_name = NULL;
const char * dim_spec = NULL;
const char * count_query = NULL;
const char * extent = NULL;
const char * ogr_file = NULL;
const char * ogr_layer = NULL;
const char * ogr_where = NULL;
const char * ogr_sql = NULL;
const char * zoom = NULL;
#ifdef USE_CLIPPERS
GEOSGeometry *region_geom;
GEOSGeometry *grid_geom;
const GEOSPreparedGeometry *region_prepgeom = NULL;
#else // Use region_bbox instead of region_geom
#endif // USE_CLIPPERS
mapcache_tileset * tileset = NULL;
mapcache_grid * grid = NULL;
mapcache_grid_link * grid_link;
apr_array_header_t * dimensions = NULL;
struct cache_info {
ezxml_t node;
mapcache_cache * cache;
int minzoom, maxzoom;
char * dbfile;
apr_hash_t * formats;
int xcount, ycount, top;
} *cache;
apr_array_header_t * caches = NULL;
int i, ix, iy, iz;
ezxml_t doc, node;
ezxml_t dbfile_node = NULL;
char * text;
apr_hash_index_t * hi;
mapcache_extent region_bbox = { 0, 0, 0, 0 };
double * list = NULL;
int nelts;
int minzoom = 0, maxzoom = 0;
int64_t tiles_max_in_cache = 0;
int64_t tiles_cached_in_cache = 0;
apr_off_t size_of_cache = 0;
int64_t tiles_in_cache = 0;
apr_hash_t * db_files = NULL;
int cid;
int nb_missing_files = 0;
int report_missing_files = TRUE;
/////////////////////////////////////////////////////////////////////////////
// Initialize Apache, GEOS, OGR, cJSON and Mapcache
//
apr_initialize();
#ifdef USE_CLIPPERS
initGEOS(notice, log_and_exit);
OGRRegisterAll();
#endif // USE_CLIPPERS
apr_pool_create(&ctx.pool, NULL);
_create_json_pool(ctx.pool);
mapcache_context_init(&ctx);
ctx.config = mapcache_configuration_create(ctx.pool);
ctx.log = mapcache_log;
mapcache_cache_child_init(&ctx,ctx.config,ctx.pool);
if (GC_HAS_ERROR(&ctx)) goto failure;
mapcache_connection_pool_create(ctx.config, &ctx.connection_pool, ctx.pool);
/////////////////////////////////////////////////////////////////////////////
// Parse command-line options
//
apr_getopt_init(&opt, ctx.pool, argc, (const char*const*)argv);
while ((status = apr_getopt_long(opt, optlist, &optk, &optv)) == APR_SUCCESS)
{
switch (optk) {
case 'h': // --help
usage(ctx.pool, argv[0], NULL);
goto success;
break;
case 'c': // --config
config_file = optv;
break;
case 't': // --tileset
tileset_name = optv;
break;
case 'g': // --grid
grid_name = optv;
break;
case 'D': // --dimension
if (!dim_spec) {
dim_spec = optv;
} else {
dim_spec = apr_pstrcat(ctx.pool, dim_spec, ":", optv, NULL);
}
break;
case 'q': // --query
count_query = optv;
break;
case 'e': // --extent ,,,
extent = optv;
break;
case 'd': // --ogr-datasource
ogr_file = optv;
break;
case 'l': // --ogr-layer
ogr_layer = optv;
break;
case 'w': // --ogr-where
ogr_where = optv;
break;
case 's': // --ogr-sql
ogr_sql = optv;
break;
case 'z': // --zoom [,]
zoom = optv;
break;
case 'o': // --short-output
report_missing_files = FALSE;
break;
}
}
if (status != APR_EOF) {
usage(ctx.pool, argv[0], "Bad options");
goto failure;
}
/////////////////////////////////////////////////////////////////////////////
// Load Mapcache configuration file in Mapcache internal data structure
//
if (!config_file) {
usage(ctx.pool, argv[0], "Configuration file has not been specified");
goto failure;
}
mapcache_configuration_parse(&ctx, config_file, ctx.config, 0);
if (GC_HAS_ERROR(&ctx)) goto failure;
/////////////////////////////////////////////////////////////////////////////
// Retrieve tileset information
//
if (!tileset_name) {
usage(ctx.pool, argv[0], "Tileset has not been specified");
goto failure;
}
tileset = mapcache_configuration_get_tileset(ctx.config, tileset_name);
if (!tileset) {
ctx.set_error(&ctx, 500,
"Tileset \"%s\" has not been found in configuration \"%s\"",
tileset_name, config_file);
goto failure;
}
/////////////////////////////////////////////////////////////////////////////
// Retrieve grid information
//
if (!grid_name) {
usage(ctx.pool, argv[0], "Grid has not been specified");
goto failure;
}
for (i=0 ; igrid_links->nelts ; i++) {
grid_link = APR_ARRAY_IDX(tileset->grid_links, i, mapcache_grid_link*);
if (strcmp(grid_link->grid->name, grid_name)==0) {
grid = grid_link->grid;
break;
}
}
if (!grid) {
ctx.set_error(&ctx, 500,
"Grid \"%s\" has not been found in tileset \"%s\"",
grid_name, tileset->name);
goto failure;
}
/////////////////////////////////////////////////////////////////////////////
// Retrieve region of interest geometry, either from --extent or from
// --ogr-... option group
//
if (extent && ogr_file) {
ctx.set_error(&ctx, 500,
"Extent and OGR Data Source are mutually exclusive");
goto failure;
}
if (!ogr_file && (ogr_sql || ogr_layer || ogr_where)) {
ctx.set_error(&ctx, 500,
"OGR Data Source is required with other OGR related options");
goto failure;
}
if (ogr_sql && (ogr_layer || ogr_where)) {
ctx.set_error(&ctx, 500,
"--ogr-sql cannot be used with --ogr-layer or --ogr-where");
goto failure;
}
// Region of interest is specified with --extent
if (extent) {
#ifdef USE_CLIPPERS
GEOSGeometry *temp;
#endif
if (mapcache_util_extract_double_list(&ctx, extent, ",", &list, &nelts)
!= MAPCACHE_SUCCESS || nelts != 4)
{
usage(ctx.pool, argv[0], "Failed to parse extent: \"%s\"", extent);
goto failure;
}
region_bbox.minx = list[0];
region_bbox.miny = list[1];
region_bbox.maxx = list[2];
region_bbox.maxy = list[3];
// Swap bounds if inverted
if (region_bbox.minx > region_bbox.maxx) {
double swap = region_bbox.minx;
region_bbox.minx = region_bbox.maxx;
region_bbox.maxx = swap;
}
if (region_bbox.miny > region_bbox.maxy) {
double swap = region_bbox.miny;
region_bbox.miny = region_bbox.maxy;
region_bbox.maxy = swap;
}
#ifdef USE_CLIPPERS
temp = mapcache_extent_to_GEOSGeometry(®ion_bbox);
region_geom = temp;
#else // Use region_bbox instead of region_geom
#endif
}
#ifdef USE_CLIPPERS
// Region of interest is specified with OGR
if (ogr_file) {
OGRDataSourceH ogr = NULL;
OGRLayerH layer = NULL;
OGRFeatureH feature;
GEOSWKTReader *geoswktreader;
int nFeatures;
ogr = OGROpen(ogr_file, FALSE, NULL);
if (!ogr) {
ctx.set_error(&ctx, 500, "Failed to open OGR data source: %s", ogr_file);
goto failure;
}
// Get layer from OGR data source
if (ogr_sql) {
// Get layer from SQL
layer = OGR_DS_ExecuteSQL(ogr,ogr_sql, NULL, NULL);
if (!layer) {
ctx.set_error(&ctx, 500, "Failed to get OGR layer from OGR SQL query");
}
} else {
// Get layer from OGR layer / OGR where
int nlayers = OGR_DS_GetLayerCount(ogr);
if (nlayers > 1 && !ogr_layer) {
ctx.set_error(&ctx, 500, "OGR data source has more than one layer"
" but OGR layer has not been specified");
goto failure;
} else if (ogr_layer) {
layer = OGR_DS_GetLayerByName(ogr, ogr_layer);
} else {
layer = OGR_DS_GetLayer(ogr, 0);
}
if (!layer) {
ctx.set_error(&ctx, 500, "Failed to find OGR layer");
goto failure;
}
if (ogr_where) {
if (OGR_L_SetAttributeFilter(layer, ogr_where) != OGRERR_NONE) {
ctx.set_error(&ctx, 500, "Failed to filter with --ogr-where %s",
ogr_where);
goto failure;
}
}
}
OGR_L_ResetReading(layer);
// Get geometry from layer
nFeatures = OGR_L_GetFeatureCount(layer, TRUE);
if (nFeatures == 0) {
ctx.set_error(&ctx, 500, "Failed to find features in OGR layer");
goto failure;
}
region_geom = GEOSGeom_createEmptyPolygon();
geoswktreader = GEOSWKTReader_create();
nFeatures = 0;
while ((feature = OGR_L_GetNextFeature(layer))) {
char *wkt;
GEOSGeometry *geos_geom, *temp;
OGREnvelope ogr_extent;
OGRGeometryH ogr_geom = OGR_F_GetGeometryRef(feature);
if (!ogr_geom || !OGR_G_IsValid(ogr_geom)) continue;
OGR_G_ExportToWkt(ogr_geom,&wkt);
geos_geom = GEOSWKTReader_read(geoswktreader,wkt);
CPLFree(wkt);
OGR_G_GetEnvelope(ogr_geom, &ogr_extent);
if (nFeatures == 0) {
region_bbox.minx = ogr_extent.MinX;
region_bbox.miny = ogr_extent.MinY;
region_bbox.maxx = ogr_extent.MaxX;
region_bbox.maxy = ogr_extent.MaxY;
} else {
region_bbox.minx = fminl(region_bbox.minx, ogr_extent.MinX);
region_bbox.miny = fminl(region_bbox.miny, ogr_extent.MinY);
region_bbox.maxx = fmaxl(region_bbox.maxx, ogr_extent.MaxX);
region_bbox.maxy = fmaxl(region_bbox.maxy, ogr_extent.MaxY);
}
nFeatures++;
temp = GEOSUnion(region_geom, geos_geom);
GEOSGeom_destroy(region_geom);
region_geom = temp;
}
GEOSWKTReader_destroy(geoswktreader);
}
#endif // USE_CLIPPERS
// Set region to grid extent when no region has been provided
if (!extent && !ogr_file) {
#ifdef USE_CLIPPERS
GEOSGeometry *temp;
#endif
region_bbox.minx = grid->extent.minx;
region_bbox.miny = grid->extent.miny;
region_bbox.maxx = grid->extent.maxx;
region_bbox.maxy = grid->extent.maxy;
#ifdef USE_CLIPPERS
temp = mapcache_extent_to_GEOSGeometry(®ion_bbox);
region_geom = temp;
#else // Use region_bbox instead of region_geom
#endif
}
// Region of interest must be within grid extent
#ifdef USE_CLIPPERS
region_prepgeom = GEOSPrepare(region_geom);
grid_geom = mapcache_extent_to_GEOSGeometry(&(grid->extent));
if (GEOSPreparedWithin(region_prepgeom, grid_geom) != 1) {
#else // Use region_bbox instead of region_geom
if ( (region_bbox.minx < grid->extent.minx)
|| (region_bbox.miny < grid->extent.miny)
|| (region_bbox.maxx > grid->extent.maxx)
|| (region_bbox.maxy > grid->extent.maxy))
{
#endif // USE_CLIPPERS
ctx.set_error(&ctx, 500,
"Requested geometry is not contained within Grid extent: "
"[ %.18g, %.18g, %.18g, %.18g ]\n", grid->extent.minx,
grid->extent.miny, grid->extent.maxx, grid->extent.maxy);
goto failure;
}
/////////////////////////////////////////////////////////////////////////////
// Load MapCache configuration again, this time as an XML document, in order
// to gain access to settings that are unreacheable from Mapcache API
//
doc = ezxml_parse_file(config_file);
/////////////////////////////////////////////////////////////////////////////
// Retrieve cache information from XML document
//
// Create table of caches
if (!caches) caches = apr_array_make(ctx.pool, 1, sizeof(void*));
// Retrieve cache element in XML configuration
cache = apr_palloc(ctx.pool, sizeof(struct cache_info));
cache->cache = tileset->_cache;
cache->node = NULL;
for (node = ezxml_child(doc, "cache") ; node ; node = node->next) {
if (strcmp(ezxml_attr(node, "name"), cache->cache->name) == 0) {
cache->node = node;
break;
}
}
// Retrieve individuals caches in the composite
if (cache->cache->type == MAPCACHE_CACHE_COMPOSITE) {
for (node = ezxml_child(cache->node, "cache") ; node ; node = node->next) {
struct cache_info * c = apr_palloc(ctx.pool, sizeof(struct cache_info));
const char * val;
ezxml_t n;
// Read min-zoom and max-zoom attributes of reference
c->minzoom = 0;
c->maxzoom = INT_MAX;
val = ezxml_attr(node, "min-zoom");
if (val) c->minzoom = (int)strtol(val, NULL, 10);
val = ezxml_attr(node, "max-zoom");
if (val) c->maxzoom = (int)strtol(val, NULL, 10);
// Retrieve individual cache element in XML configuration
c->cache = mapcache_configuration_get_cache(ctx.config, node->txt);
c->node = NULL;
for (n = ezxml_child(doc, "cache") ; n ; n = n->next) {
if (strcmp(ezxml_attr(n, "name"), c->cache->name) == 0) {
c->node = n;
break;
}
}
APR_ARRAY_PUSH(caches, struct cache_info*) = c;
}
}
else {
APR_ARRAY_PUSH(caches, struct cache_info*) = cache;
}
// Retrieve information on all stored caches
for ( cid=0 ; cid < caches->nelts ; cid++ ) {
struct cache_info * c = APR_ARRAY_IDX(caches, cid, struct cache_info*);
// Only SQLite caches are handled
if (c->cache->type != MAPCACHE_CACHE_SQLITE) {
ctx.set_error(&ctx, 500,
"cache \"%s\" of tileset \"%s\" is not of type SQLite",
c->cache->name, tileset->name);
goto failure;
}
// Read element from
dbfile_node = ezxml_child(c->node, "dbfile");
c->dbfile = dbfile_node->txt;
if (!c->dbfile) {
ctx.set_error(&ctx, 500,
"Failed to parse tag of cache \"%s\"", c->cache->name);
goto failure;
}
// Read formats of x,y,z placeholders in dbfile template
c->formats = apr_hash_make(ctx.pool);
apr_hash_set(c->formats, "x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "y", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "z", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_y", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "div_x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "div_y", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_div_x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_div_y", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "top", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "top_x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "top_y", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_top_x", APR_HASH_KEY_STRING, "(not set)");
apr_hash_set(c->formats, "inv_top_y", APR_HASH_KEY_STRING, "(not set)");
for (hi = apr_hash_first(ctx.pool, c->formats)
; hi
; hi = apr_hash_next(hi))
{
const char *key, *val, *attr;
apr_hash_this(hi, (const void**)&key, NULL, (void**)&val);
attr = apr_pstrcat(ctx.pool, key, "_fmt", NULL);
val = ezxml_attr(dbfile_node, attr);
if (!val) val = "%d";
apr_hash_set(c->formats, key, APR_HASH_KEY_STRING, val);
}
// Read xcount and ycount
c->xcount = c->ycount = -1;
node = ezxml_child(c->node, "xcount");
text = NULL;
if (node) text = node->txt;
if (text) c->xcount = (int)strtol(text, NULL, 10);
node = ezxml_child(c->node, "ycount");
text = NULL;
if (node) text = node->txt;
if (text) c->ycount = (int)strtol(text, NULL, 10);
// Read top
c->top = -1;
node = ezxml_child(c->node, "top");
text = NULL;
if (node) text = node->txt;
if (text) c->top = (int)strtol(text, NULL, 10);
}
/////////////////////////////////////////////////////////////////////////////
// Retrieve dimensions information
//
if (tileset->dimensions) {
// Set up dimensions with default values
dimensions = apr_array_make(ctx.pool, tileset->dimensions->nelts,
sizeof(mapcache_requested_dimension*));
for ( i=0 ; i < tileset->dimensions->nelts ; i++ ) {
mapcache_dimension * dim;
mapcache_requested_dimension * reqdim;
dim = APR_ARRAY_IDX(tileset->dimensions, i, mapcache_dimension*);
reqdim = apr_pcalloc(ctx.pool, sizeof(mapcache_requested_dimension));
reqdim->dimension = dim;
reqdim->requested_value = dim->default_value;
reqdim->cached_value = dim->default_value;
APR_ARRAY_PUSH(dimensions, mapcache_requested_dimension*) = reqdim;
}
// Update dimensions with values specified with -D command line option
// syntax is: "dim1=value1:dim2=value2:..."
if (dim_spec) {
char * ds = apr_pstrdup(ctx.pool, dim_spec);
char *kvp, *last;
for (kvp=apr_strtok(ds, ":", &last)
; kvp ; kvp = apr_strtok(NULL, ":", &last))
{
char *key, *val, *sav;
key = apr_strtok(kvp, "=", &sav);
val = apr_strtok(NULL, "=", &sav);
if (!key || !val) {
usage(ctx.pool, argv[0],
"Can't parse dimension settings: %s", dim_spec);
goto failure;
}
mapcache_set_requested_dimension(&ctx, dimensions, key, val);
mapcache_set_cached_dimension(&ctx, dimensions, key, val);
if (GC_HAS_ERROR(&ctx)) goto failure;
}
}
// Check that dimension values are valid
for ( i=0 ; i < dimensions->nelts ; i++) {
mapcache_requested_dimension *entry;
apr_array_header_t * vals;
entry = APR_ARRAY_IDX(dimensions, i, mapcache_requested_dimension*);
vals = mapcache_dimension_get_entries_for_value(&ctx,
entry->dimension, entry->requested_value, tileset, NULL, grid);
if (GC_HAS_ERROR(&ctx)) goto failure;
if (!vals || vals->nelts == 0) {
ctx.set_error(&ctx, 500,
"invalid value \"%s\" for dimension \"%s\"\n",
entry->requested_value, entry->dimension->name);
goto failure;
}
}
}
/////////////////////////////////////////////////////////////////////////////
// Set default query for counting tiles in a rectangular part of a SQLite
// cache file
//
if (!count_query) {
count_query = "SELECT count(rowid)"
" FROM tiles"
" WHERE (x between :minx and :maxx)"
" AND (y between :miny and :maxy)"
" AND (z=:z)"
" AND tileset=:tileset AND grid=:grid AND dim=:dim";
}
/////////////////////////////////////////////////////////////////////////////
// Retrieve zoom level interval (defaults to 0)
//
if (zoom) {
minzoom = strtol(zoom, &text, 10);
maxzoom = minzoom;
if (*text == ',') {
maxzoom = strtol(text+1, &text, 10);
}
if (*text != '\0') {
usage(ctx.pool, argv[0], "Bad int format for zoom level: %s", zoom);
goto failure;
}
if (minzoom > maxzoom) {
int swap = minzoom;
minzoom = maxzoom;
maxzoom = swap;
}
if (minzoom < 0) {
ctx.set_error(&ctx, 500,
"Zoom level %d not in valid interval [ %d, %d ]",
minzoom, 0, grid->nlevels-1);
goto failure;
}
if (maxzoom >= grid->nlevels) {
ctx.set_error(&ctx, 500,
"Zoom level %d not in valid interval [ %d, %d ]",
maxzoom, 0, grid->nlevels-1);
goto failure;
}
}
/////////////////////////////////////////////////////////////////////////////
// Report global identification information
//
if (json_output) {
jreport = cJSON_CreateObject();
cJSON_AddStringToObject(jreport, "layer", tileset->name);
cJSON_AddStringToObject(jreport, "grid", grid->name);
cJSON_AddStringToObject(jreport, "unit",
grid->unit==MAPCACHE_UNIT_METERS? "m":
grid->unit==MAPCACHE_UNIT_DEGREES?"dd":"ft");
jregion = cJSON_CreateObject();
cJSON_AddItemToObject(jreport, "region", jregion);
jitem = cJSON_AddArrayToObject(jregion, "bounding_box");
cJSON_AddNumberToObject(jitem, "", region_bbox.minx);
cJSON_AddNumberToObject(jitem, "", region_bbox.miny);
cJSON_AddNumberToObject(jitem, "", region_bbox.maxx);
cJSON_AddNumberToObject(jitem, "", region_bbox.maxy);
#ifdef USE_CLIPPERS
cJSON_AddItemToObject(jregion, "geometry",
GEOSGeometry_to_cJSON(region_geom));
#else // Use region_bbox instead of region_geom
cJSON_AddItemToObject(jregion, "geometry",
mapcache_extent_to_cJSON(®ion_bbox));
#endif // USE_CLIPPERS
jzooms = cJSON_AddArrayToObject(jreport, "zoom_levels");
}
/////////////////////////////////////////////////////////////////////////////
// Iterate over all tiles of all DB files of all requested zoom levels within
// region of interest
//
// Iterate over all requested zoom levels
for (iz = minzoom ; iz <= maxzoom ; iz ++) {
int64_t tiles_max_in_level = 0;
int64_t tiles_cached_in_level = 0;
mapcache_extent_i til_region_bbox;
mapcache_extent_i db_region_bbox;
int dbx_has_inv = FALSE;
int dby_has_inv = FALSE;
int file_zoom_level;
// Select cache according to zoom level
for ( cid=0 ; cid < caches->nelts ; cid++ ) {
cache = APR_ARRAY_IDX(caches, cid, struct cache_info*);
if ((iz >= cache->minzoom) && (iz <= cache->maxzoom)) break;
}
if (cache->cache->type != MAPCACHE_CACHE_SQLITE) {
ctx.set_error(&ctx, 500,
"cache \"%s\" of tileset \"%s\" is not of type SQLite",
cache->cache->name, tileset->name);
goto failure;
}
// Report identification information for current zoom level
if (json_output) {
jzoom = cJSON_CreateObject();
cJSON_AddItemToObject(jzooms, "", jzoom);
cJSON_AddNumberToObject(jzoom, "level", iz);
jfiles = cJSON_AddArrayToObject(jzoom, "files");
}
// Compute region bounding box expressed in tiles and in DB files for the
// current zoom level
file_zoom_level = iz;
if (cache->top > 0) file_zoom_level = cache->top;
mapcache_grid_get_xy(&ctx, grid, region_bbox.minx, region_bbox.miny,
file_zoom_level, &(til_region_bbox.minx), &(til_region_bbox.miny));
mapcache_grid_get_xy(&ctx, grid, region_bbox.maxx, region_bbox.maxy,
file_zoom_level, &(til_region_bbox.maxx), &(til_region_bbox.maxy));
if (til_region_bbox.minx > til_region_bbox.maxx) {
int swap = til_region_bbox.maxx;
til_region_bbox.maxx = til_region_bbox.minx;
til_region_bbox.minx = swap;
}
if (til_region_bbox.miny > til_region_bbox.maxy) {
int swap = til_region_bbox.maxy;
til_region_bbox.maxy = til_region_bbox.miny;
til_region_bbox.miny = swap;
}
dbx_has_inv = strstr(cache->dbfile,"{inv_x}")
|| strstr(cache->dbfile,"{inv_div_x}")
|| strstr(cache->dbfile,"{inv_top_x}");
dby_has_inv = strstr(cache->dbfile,"{inv_y}")
|| strstr(cache->dbfile,"{inv_div_y}")
|| strstr(cache->dbfile,"{inv_top_y}");
if (cache->top > 0) {
if (dbx_has_inv) {
db_region_bbox.minx = grid->levels[cache->top]->maxx-1 - til_region_bbox.maxx;
db_region_bbox.maxx = grid->levels[cache->top]->maxx-1 - til_region_bbox.minx;
} else {
db_region_bbox.minx = til_region_bbox.minx;
db_region_bbox.maxx = til_region_bbox.maxx;
}
if (dby_has_inv) {
db_region_bbox.miny = grid->levels[cache->top]->maxy-1 - til_region_bbox.maxy;
db_region_bbox.maxy = grid->levels[cache->top]->maxy-1 - til_region_bbox.miny;
} else {
db_region_bbox.miny = til_region_bbox.miny;
db_region_bbox.maxy = til_region_bbox.maxy;
}
} else if ((cache->xcount > 0) && (cache->ycount > 0)) {
if (dbx_has_inv) {
int inv_minx = grid->levels[iz]->maxx - til_region_bbox.minx;
int inv_maxx = grid->levels[iz]->maxx - til_region_bbox.maxx;
db_region_bbox.minx = floor(inv_maxx/cache->ycount);
db_region_bbox.maxx = floor(inv_minx/cache->ycount);
} else {
db_region_bbox.minx = floor(til_region_bbox.minx/cache->xcount);
db_region_bbox.maxx = floor(til_region_bbox.maxx/cache->xcount);
}
if (dby_has_inv) {
int inv_miny = grid->levels[iz]->maxy - til_region_bbox.miny;
int inv_maxy = grid->levels[iz]->maxy - til_region_bbox.maxy;
db_region_bbox.miny = floor(inv_maxy/cache->ycount);
db_region_bbox.maxy = floor(inv_miny/cache->ycount);
} else {
db_region_bbox.miny = floor(til_region_bbox.miny/cache->ycount);
db_region_bbox.maxy = floor(til_region_bbox.maxy/cache->ycount);
}
} else {
db_region_bbox.minx = 0;
db_region_bbox.miny = 0;
db_region_bbox.maxx = 0;
db_region_bbox.maxy = 0;
}
// Iterate over DB files of current level within region bounding box
if (!db_files) db_files = apr_hash_make(ctx.pool);
for (ix = db_region_bbox.minx ; ix <= db_region_bbox.maxx ; ix++) {
for (iy = db_region_bbox.miny ; iy <= db_region_bbox.maxy ; iy++) {
int tiles_max_in_file = 0;
int tiles_cached_in_file = 0;
char * file_name;
apr_status_t file_open_report;
apr_file_t * filehandle;
apr_finfo_t fileinfo;
mapcache_extent_i til_file_bbox;
mapcache_extent file_bbox;
mapcache_extent temp_bbox;
mapcache_extent region_in_file_bbox;
#ifdef USE_CLIPPERS
GEOSGeometry *file_geom;
GEOSGeometry *temp_geom;
GEOSGeometry *region_in_file_geom;
const GEOSGeometry *temp_ring;
int npoints, p;
#endif // USE_CLIPPERS
mapcache_extent_i til_region_in_file_bbox;
int region_in_file_is_rectangle = FALSE;
int region_in_file_is_empty = FALSE;
apr_off_t *sizeref;
double res;
// Display progression
if (show_progress) {
double incz = 1.0 / (double)(maxzoom - minzoom + 1);
double incx = incz / (double)(db_region_bbox.maxx
- db_region_bbox.minx + 1);
double incy = incx / (double)(db_region_bbox.maxy
- db_region_bbox.miny + 1);
double progz = (double)(iz - minzoom) * incz;
double progx = (double)(ix - db_region_bbox.minx) * incx;
double progy = (double)(iy - db_region_bbox.miny) * incy;
fprintf(stderr, "\033[2K In progress (z:%d x:%d y:%d): %.3f%% done\r",
iz, ix, iy, (progz + progx + progy) * 100.0);
fflush(stderr);
}
// Retrieve DB file name and check for its existence (read access)
file_name = dbfilename(ctx.pool, cache->dbfile, tileset, grid,
dimensions, cache->formats, iz, ix, iy, cache->xcount,
cache->ycount, cache->top);
// Unless this has already been done on this file,
// Retrieve file size and count cached tiles regardless the region of
// interest (for average tile size estimation)
fileinfo.size = 0;
sizeref = apr_hash_get(db_files, file_name, APR_HASH_KEY_STRING);
if (sizeref) {
fileinfo.size = *sizeref;
} else {
file_open_report = apr_file_open(&filehandle, file_name,
APR_FOPEN_READ|APR_FOPEN_BINARY, APR_FPROT_OS_DEFAULT, ctx.pool);
if (file_open_report == APR_SUCCESS) {
int level;
// Retrieve file size
apr_file_info_get(&fileinfo, APR_FINFO_SIZE, filehandle);
apr_file_close(filehandle);
sizeref = apr_pcalloc(ctx.pool, sizeof(apr_off_t));
*sizeref = fileinfo.size;
apr_hash_set(db_files, file_name, APR_HASH_KEY_STRING, sizeref);
size_of_cache += fileinfo.size;
// Retrieve total number of cached tiles in file
for (level = 0 ; level < grid->nlevels ; level++) {
int tmpmax, tmpcached;
const mapcache_extent_i full_extent = { 0, 0, INT_MAX, INT_MAX };
count_tiles_in_rectangle(&ctx, level, full_extent, tileset,
grid_link, dimensions, file_name, count_query, &tmpmax,
&tmpcached);
if (GC_HAS_ERROR(&ctx)) goto failure;
tiles_in_cache += tmpcached;
}
}
else
{
nb_missing_files++ ;
}
}
// Compute file bounding box expressed in tiles
if (cache->top > 0) {
if (dbx_has_inv) {
til_file_bbox.minx = grid->levels[cache->top]->maxx-1 - ix;
til_file_bbox.maxx = til_file_bbox.minx;
} else {
til_file_bbox.minx = ix;
til_file_bbox.maxx = til_file_bbox.minx;
}
if (dby_has_inv) {
til_file_bbox.miny = grid->levels[cache->top]->maxy-1 - iy;
til_file_bbox.maxy = til_file_bbox.miny;
} else {
til_file_bbox.miny = iy;
til_file_bbox.maxy = til_file_bbox.miny;
}
} else if ((cache->xcount > 0) && (cache->ycount > 0)) {
if (dbx_has_inv) {
til_file_bbox.maxx = grid->levels[iz]->maxx-1 - ix * cache->xcount;
til_file_bbox.minx = til_file_bbox.maxx + cache->xcount + 1;
} else {
til_file_bbox.minx = ix * cache->xcount;
til_file_bbox.maxx = til_file_bbox.minx + cache->xcount - 1;
}
if (dby_has_inv) {
til_file_bbox.maxy = grid->levels[iz]->maxy-1 - iy * cache->ycount;
til_file_bbox.miny = til_file_bbox.maxy - cache->ycount + 1;
} else {
til_file_bbox.miny = iy * cache->ycount;
til_file_bbox.maxy = til_file_bbox.miny + cache->ycount - 1;
}
if (til_file_bbox.minx < 0) til_file_bbox.minx = 0;
if (til_file_bbox.miny < 0) til_file_bbox.miny = 0;
if (til_file_bbox.maxx >= grid->levels[iz]->maxx) {
til_file_bbox.maxx = grid->levels[iz]->maxx - 1;
}
if (til_file_bbox.maxy >= grid->levels[iz]->maxy) {
til_file_bbox.maxy = grid->levels[iz]->maxy - 1;
}
} else {
til_file_bbox.minx = 0;
til_file_bbox.miny = 0;
til_file_bbox.maxx = grid->levels[iz]->maxx - 1;
til_file_bbox.maxy = grid->levels[iz]->maxy - 1;
}
// Compute file bounding box expressed in grid units for the current
// zoom level
mapcache_grid_get_tile_extent(&ctx, grid, til_file_bbox.minx,
til_file_bbox.miny, file_zoom_level, &temp_bbox);
if (GC_HAS_ERROR(&ctx)) goto failure;
file_bbox.minx = temp_bbox.minx;
file_bbox.miny = temp_bbox.miny;
mapcache_grid_get_tile_extent(&ctx, grid, til_file_bbox.maxx,
til_file_bbox.maxy, file_zoom_level, &temp_bbox);
if (GC_HAS_ERROR(&ctx)) goto failure;
file_bbox.maxx = temp_bbox.maxx;
file_bbox.maxy = temp_bbox.maxy;
if (file_bbox.minx > file_bbox.maxx) {
int swap = file_bbox.maxx;
file_bbox.maxx = file_bbox.minx;
file_bbox.minx = swap;
}
if (file_bbox.miny > file_bbox.maxy) {
int swap = file_bbox.maxy;
file_bbox.maxy = file_bbox.miny;
file_bbox.miny = swap;
}
// Compute part of region of interest within file bounding box
#ifdef USE_CLIPPERS
file_geom = mapcache_extent_to_GEOSGeometry(&file_bbox);
region_in_file_geom = GEOSIntersection(region_geom, file_geom);
region_in_file_is_empty = GEOSisEmpty(region_in_file_geom);
#else // use _bbox instead of _geom
region_in_file_is_rectangle = TRUE;
region_in_file_bbox.minx = fmaxl(region_bbox.minx, file_bbox.minx);
region_in_file_bbox.maxx = fminl(region_bbox.maxx, file_bbox.maxx);
if (region_in_file_bbox.minx > region_in_file_bbox.maxx) {
region_in_file_bbox.minx = region_in_file_bbox.maxx = 0;
region_in_file_is_empty = TRUE;
}
region_in_file_bbox.miny = fmaxl(region_bbox.miny, file_bbox.miny);
region_in_file_bbox.maxy = fminl(region_bbox.maxy, file_bbox.maxy);
if (region_in_file_bbox.miny > region_in_file_bbox.maxy) {
region_in_file_bbox.miny = region_in_file_bbox.maxy = 0;
region_in_file_is_empty = TRUE;
}
#endif // USE_CLIPPERS
// Jump to next file if this one is outside the region of interest
if (region_in_file_is_empty) continue;
#ifdef USE_CLIPPERS
// Compute bounding box of region/file intersection expressed in grid
// units
temp_geom = GEOSEnvelope(region_in_file_geom);
temp_ring = GEOSGetExteriorRing(temp_geom);
npoints = GEOSGeomGetNumPoints(temp_ring);
for (p=0 ; plevels[iz]->resolution;
mapcache_grid_get_xy(&ctx, grid, region_in_file_bbox.maxx-res,
region_in_file_bbox.maxy-res, iz, &(til_region_in_file_bbox.maxx),
&(til_region_in_file_bbox.maxy));
if (til_region_in_file_bbox.minx > til_region_in_file_bbox.maxx) {
int swap = til_region_in_file_bbox.maxx;
til_region_in_file_bbox.maxx = til_region_in_file_bbox.minx;
til_region_in_file_bbox.minx = swap;
}
if (til_region_in_file_bbox.miny > til_region_in_file_bbox.maxy) {
int swap = til_region_in_file_bbox.maxy;
til_region_in_file_bbox.maxy = til_region_in_file_bbox.miny;
til_region_in_file_bbox.miny = swap;
}
if ((cache->xcount > 0) && (cache->ycount > 0)) {
if (til_region_in_file_bbox.maxx>(til_file_bbox.minx+cache->xcount-1))
{
(til_region_in_file_bbox.maxx)--;
}
if (til_region_in_file_bbox.maxy>(til_file_bbox.miny+cache->ycount-1))
{
(til_region_in_file_bbox.maxy)--;
}
}
// If region/file intersection is a rectangle, count tiles in a single
// step
if (region_in_file_is_rectangle) {
int tmpmax, tmpcached;
count_tiles_in_rectangle(
&ctx,
iz,
til_region_in_file_bbox,
tileset,
grid_link,
dimensions,
file_name,
count_query,
&tmpmax,
&tmpcached
);
tiles_max_in_file += tmpmax;
tiles_cached_in_file += tmpcached;
}
#ifdef USE_CLIPPERS
// Else, if file is partially inside region, iterate over tiles
else {
int tmpmax, tmpcached;
count_tiles_in_region(
&ctx,
iz,
til_region_in_file_bbox,
tileset,
grid_link,
dimensions,
region_prepgeom,
(file_open_report==APR_SUCCESS),
&tmpmax,
&tmpcached
);
tiles_max_in_file += tmpmax;
tiles_cached_in_file += tmpcached;
}
#endif // USE_CLIPPERS
// Report identification and coverage information for a single DB file
// for current zoom level and extent
if (json_output) {
if (report_missing_files || (file_open_report == APR_SUCCESS)) {
jfile = cJSON_CreateObject();
cJSON_AddItemToObject(jfiles, "", jfile);
cJSON_AddStringToObject(jfile, "file_name", file_name);
cJSON_AddNumberToObject(jfile, "file_size", fileinfo.size);
jitem = cJSON_AddArrayToObject(jfile, "file_bounding_box");
cJSON_AddNumberToObject(jitem, "", file_bbox.minx);
cJSON_AddNumberToObject(jitem, "", file_bbox.miny);
cJSON_AddNumberToObject(jitem, "", file_bbox.maxx);
cJSON_AddNumberToObject(jitem, "", file_bbox.maxy);
jregion = cJSON_CreateObject();
cJSON_AddItemToObject(jfile, "region_in_file", jregion);
jitem = cJSON_AddArrayToObject(jregion, "bounding_box");
cJSON_AddNumberToObject(jitem, "", region_in_file_bbox.minx);
cJSON_AddNumberToObject(jitem, "", region_in_file_bbox.miny);
cJSON_AddNumberToObject(jitem, "", region_in_file_bbox.maxx);
cJSON_AddNumberToObject(jitem, "", region_in_file_bbox.maxy);
#ifdef USE_CLIPPERS
jitem = GEOSGeometry_to_cJSON(region_in_file_geom);
#else // use _bbox instead of _geom
jitem = mapcache_extent_to_cJSON(®ion_in_file_bbox);
#endif // USE_CLIPPERS
cJSON_AddItemToObject(jregion, "geometry", jitem);
jitem = cJSON_CreateObject();
cJSON_AddItemToObject(jfile, "nb_tiles_in_region", jitem);
cJSON_AddNumberToObject(jitem,"missing_in_file",
tiles_max_in_file - tiles_cached_in_file);
cJSON_AddNumberToObject(jitem,"cached_in_file",
tiles_cached_in_file);
cJSON_AddNumberToObject(jitem,"max_in_file", tiles_max_in_file);
cJSON_AddNumberToObject(jitem,"coverage",
(double)tiles_cached_in_file/(double)tiles_max_in_file);
}
}
// Add tiles in file to tiles in zoom level
tiles_max_in_level += tiles_max_in_file;
tiles_cached_in_level += tiles_cached_in_file;
// Release resources that are no longer needed
#ifdef USE_CLIPPERS
GEOSGeom_destroy(file_geom);
GEOSGeom_destroy(region_in_file_geom);
#endif // USE_CLIPPERS
}
}
// Add tiles in level to tiles in cache
tiles_max_in_cache += tiles_max_in_level;
tiles_cached_in_cache += tiles_cached_in_level;
// Report coverage information for current zoom level and extent
if (json_output) {
jitem = cJSON_CreateObject();
cJSON_AddItemToObject(jzoom, "nb_tiles_in_region", jitem);
cJSON_AddNumberToObject(jitem, "missing_in_level",
tiles_max_in_level - tiles_cached_in_level);
cJSON_AddNumberToObject(jitem, "cached_in_level", tiles_cached_in_level);
cJSON_AddNumberToObject(jitem, "max_in_level", tiles_max_in_level);
cJSON_AddNumberToObject(jitem,"coverage",
(double)tiles_cached_in_level/(double)tiles_max_in_level);
}
}
// Report global coverage information
if (json_output) {
jitem = cJSON_CreateObject();
cJSON_AddItemToObject(jreport, "nb_tiles_in_region", jitem);
cJSON_AddNumberToObject(jitem, "missing_in_cache",
tiles_max_in_cache - tiles_cached_in_cache);
cJSON_AddNumberToObject(jitem, "cached_in_cache", tiles_cached_in_cache);
cJSON_AddNumberToObject(jitem, "max_in_cache", tiles_max_in_cache);
cJSON_AddNumberToObject(jitem,"coverage",
(double)tiles_cached_in_cache/(double)tiles_max_in_cache);
jitem = cJSON_CreateObject();
cJSON_AddItemToObject(jreport, "sizes", jitem);
cJSON_AddNumberToObject(jitem, "total_size_of_files", size_of_cache);
cJSON_AddNumberToObject(jitem, "total_nbtiles_in_files", tiles_in_cache);
if (tiles_in_cache > 0) {
apr_off_t average_tile_size = size_of_cache/tiles_in_cache;
cJSON_AddNumberToObject(jitem, "average_tile_size", average_tile_size);
cJSON_AddNumberToObject(jitem, "estimated_max_cache_size",
average_tile_size*tiles_max_in_cache);
cJSON_AddNumberToObject(jitem, "estimated_cached_cache_size",
average_tile_size*tiles_cached_in_cache);
cJSON_AddNumberToObject(jitem, "estimated_missing_cache_size",
average_tile_size*(tiles_max_in_cache-tiles_cached_in_cache));
} else {
const char * na = "N/A: cache is empty";
cJSON_AddStringToObject(jitem, "average_tile_size", na);
cJSON_AddStringToObject(jitem, "estimated_max_cache_size", na);
cJSON_AddNumberToObject(jitem, "estimated_cached_cache_size", 0);
cJSON_AddStringToObject(jitem, "estimated_missing_cache_size", na);
}
if (!report_missing_files) {
cJSON_AddNumberToObject(jreport, "nb_missing_files", nb_missing_files);
}
}
// Last progression indication
if (show_progress) {
fprintf(stderr, "\033[2K Finished: 100.000%% done\n");
}
// Display JSON report
if (json_output) {
printf("%s\n", cJSON_Print(jreport));
}
success:
_destroy_json_pool();
#ifdef USE_CLIPPERS
finishGEOS();
#endif // USE_CLIPPERS
apr_terminate();
return 0;
failure:
if (GC_HAS_ERROR(&ctx)) {
fprintf(stderr, "%s: %s\n", base_name(argv[0]),
ctx.get_error_message(&ctx));
}
_destroy_json_pool();
#ifdef USE_CLIPPERS
finishGEOS();
#endif // USE_CLIPPERS
apr_terminate();
return 1;
}
// vim: set tw=79 ts=2 sw=2 sts=2 et ai si nonu syn=c fo+=ro :
mapcache-rel-1-14-1/contrib/mapcache_detail/mapcache_detail_config.h.in 0000664 0000000 0000000 00000000174 14653160677 0026047 0 ustar 00root root 0000000 0000000 #ifndef _MAPCACHE_DETAIL_CONFIG_H
#define _MAPCACHE_DETAIL_CONFIG_H
#cmakedefine USE_OGR 1
#cmakedefine USE_GEOS 1
#endif
mapcache-rel-1-14-1/include/ 0000775 0000000 0000000 00000000000 14653160677 0015557 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/include/cJSON.h 0000664 0000000 0000000 00000034346 14653160677 0016656 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef cJSON__h
#define cJSON__h
#ifdef __cplusplus
extern "C"
{
#endif
/* project version */
#define CJSON_VERSION_MAJOR 1
#define CJSON_VERSION_MINOR 7
#define CJSON_VERSION_PATCH 3
#include
/* cJSON Types: */
#define cJSON_Invalid (0)
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6)
#define cJSON_Raw (1 << 7) /* raw json */
#define cJSON_IsReference 256
#define cJSON_StringIsConst 512
/* The cJSON structure: */
typedef struct cJSON
{
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
struct cJSON *next;
struct cJSON *prev;
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
struct cJSON *child;
/* The type of the item, as above. */
int type;
/* The item's string, if type==cJSON_String and type == cJSON_Raw */
char *valuestring;
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
int valueint;
/* The item's number, if type==cJSON_Number */
double valuedouble;
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
char *string;
} cJSON;
typedef struct cJSON_Hooks
{
void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
} cJSON_Hooks;
typedef int cJSON_bool;
#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
#define __WINDOWS__
#endif
#ifdef __WINDOWS__
/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 2 define options:
CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
For *nix builds that support visibility attribute, you can define similar behavior by
setting default visibility to hidden by adding
-fvisibility=hidden (for gcc)
or
-xldscope=hidden (for sun cc)
to CFLAGS
then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
*/
/* export symbols by default, this is necessary for copy pasting the C and header file */
#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
#define CJSON_EXPORT_SYMBOLS
#endif
#if defined(CJSON_HIDE_SYMBOLS)
#define CJSON_PUBLIC(type) type __stdcall
#elif defined(CJSON_EXPORT_SYMBOLS)
#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall
#elif defined(CJSON_IMPORT_SYMBOLS)
#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall
#endif
#else /* !WIN32 */
#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
#else
#define CJSON_PUBLIC(type) type
#endif
#endif
/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
* This is to prevent stack overflows. */
#ifndef CJSON_NESTING_LIMIT
#define CJSON_NESTING_LIMIT 1000
#endif
/* returns the version of cJSON as a string */
CJSON_PUBLIC(const char*) cJSON_Version(void);
/* Supply malloc, realloc and free functions to cJSON */
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
/* Render a cJSON entity to text for transfer/storage. */
CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
/* Render a cJSON entity to text for transfer/storage without any formatting. */
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
/* Delete a cJSON entity and all subentities. */
CJSON_PUBLIC(void) cJSON_Delete(cJSON *c);
/* Returns the number of items in an array (or object). */
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
/* Get item "string" from object. Case insensitive. */
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
/* Check if the item is a string and return its valuestring */
CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item);
/* These functions check the type of an item */
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
/* These calls create a cJSON item of the appropriate type. */
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
/* raw json */
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
/* Create a string where valuestring references a string so
* it will not be freed by cJSON_Delete */
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
/* Create an object/arrray that only references it's elements so
* they will not be freed by cJSON_Delete */
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
/* These utilities create an Array of count items. */
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count);
/* Append item to the specified array/object. */
CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
* WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
* writing to `item->string` */
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
/* Remove/Detatch items from Arrays/Objects. */
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
/* Update array items. */
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
/* Duplicate a cJSON item */
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
need to be released. With recurse!=0, it will duplicate any children connected to the item.
The item->next and ->prev pointers are always zero on return from Duplicate. */
/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
* case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
CJSON_PUBLIC(void) cJSON_Minify(char *json);
/* Helper functions for creating and adding items to an object at the same time.
* They return the added item or NULL on failure. */
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
/* When assigning an integer value, it needs to be propagated to valuedouble too. */
#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
/* helper for the cJSON_SetNumberValue macro */
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
/* Macro for iterating over an array or object */
#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
CJSON_PUBLIC(void) cJSON_free(void *object);
#ifdef __cplusplus
}
#endif
#endif
mapcache-rel-1-14-1/include/errors.h 0000664 0000000 0000000 00000003634 14653160677 0017252 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#ifndef MAPCACHE_ERRORS_H_
#define MAPCACHE_ERRORS_H_
typedef enum {
MAPCACHE_DEBUG,
MAPCACHE_INFO,
MAPCACHE_NOTICE,
MAPCACHE_WARN,
MAPCACHE_ERROR,
MAPCACHE_CRIT,
MAPCACHE_ALERT,
MAPCACHE_EMERG
} mapcache_log_level;
typedef enum {
MAPCACHE_REPORT_LOG,
MAPCACHE_REPORT_MSG,
MAPCACHE_REPORT_ERROR_IMG,
MAPCACHE_REPORT_EMPTY_IMG,
MAPCACHE_REPORT_CUSTOM_IMG
} mapcache_error_reporting;
#endif /* ERRORS_H_ */
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/include/ezxml.h 0000664 0000000 0000000 00000015732 14653160677 0017077 0 ustar 00root root 0000000 0000000 /* ezxml.h
*
* Copyright 2004-2006 Aaron Voisine
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _EZXML_H
#define _EZXML_H
#include
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
# define DLL_EXPORT __declspec(dllexport)
#else
#define DLL_EXPORT
#endif
#define EZXML_BUFSIZE 1024 // size of internal memory buffers
#define EZXML_NAMEM 0x80 // name is malloced
#define EZXML_TXTM 0x40 // txt is malloced
#define EZXML_DUP 0x20 // attribute name and value are strduped
typedef struct ezxml *ezxml_t;
struct ezxml {
char *name; // tag name
char **attr; // tag attributes { name, value, name, value, ... NULL }
char *txt; // tag character content, empty string if none
size_t off; // tag offset from start of parent tag character content
ezxml_t next; // next tag with same name in this section at this depth
ezxml_t sibling; // next tag with different name in same section and depth
ezxml_t ordered; // next tag, same section and depth, in original order
ezxml_t child; // head of sub tag list, NULL if none
ezxml_t parent; // parent tag, NULL if current tag is root tag
short flags; // additional information
};
// Given a string of xml data and its length, parses it and creates an ezxml
// structure. For efficiency, modifies the data by adding null terminators
// and decoding ampersand sequences. If you don't want this, copy the data and
// pass in the copy. Returns NULL on failure.
DLL_EXPORT ezxml_t ezxml_parse_str(char *s, size_t len);
// A wrapper for ezxml_parse_str() that accepts a file descriptor. First
// attempts to mem map the file. Failing that, reads the file into memory.
// Returns NULL on failure.
DLL_EXPORT ezxml_t ezxml_parse_fd(int fd);
// a wrapper for ezxml_parse_fd() that accepts a file name
DLL_EXPORT ezxml_t ezxml_parse_file(const char *file);
// Wrapper for ezxml_parse_str() that accepts a file stream. Reads the entire
// stream into memory and then parses it. For xml files, use ezxml_parse_file()
// or ezxml_parse_fd()
DLL_EXPORT ezxml_t ezxml_parse_fp(FILE *fp);
// returns the first child tag (one level deeper) with the given name or NULL
// if not found
DLL_EXPORT ezxml_t ezxml_child(ezxml_t xml, const char *name);
// returns the next tag of the same name in the same section and depth or NULL
// if not found
#define ezxml_next(xml) ((xml) ? xml->next : NULL)
// Returns the Nth tag with the same name in the same section at the same depth
// or NULL if not found. An index of 0 returns the tag given.
DLL_EXPORT ezxml_t ezxml_idx(ezxml_t xml, int idx);
// returns the name of the given tag
#define ezxml_name(xml) ((xml) ? xml->name : NULL)
// returns the given tag's character content or empty string if none
#define ezxml_txt(xml) ((xml) ? xml->txt : "")
// returns the value of the requested tag attribute, or NULL if not found
DLL_EXPORT const char *ezxml_attr(ezxml_t xml, const char *attr);
// Traverses the ezxml structure to retrieve a specific subtag. Takes a
// variable length list of tag names and indexes. The argument list must be
// terminated by either an index of -1 or an empty string tag name. Example:
// title = ezxml_get(library, "shelf", 0, "book", 2, "title", -1);
// This retrieves the title of the 3rd book on the 1st shelf of library.
// Returns NULL if not found.
DLL_EXPORT ezxml_t ezxml_get(ezxml_t xml, ...);
// Converts an ezxml structure back to xml. Returns a string of xml data that
// must be freed.
DLL_EXPORT char *ezxml_toxml(ezxml_t xml);
// returns a NULL terminated array of processing instructions for the given
// target
DLL_EXPORT const char **ezxml_pi(ezxml_t xml, const char *target);
// frees the memory allocated for an ezxml structure
DLL_EXPORT void ezxml_free(ezxml_t xml);
// returns parser error message or empty string if none
DLL_EXPORT const char *ezxml_error(ezxml_t xml);
// returns a new empty ezxml structure with the given root tag name
DLL_EXPORT ezxml_t ezxml_new(const char *name);
// wrapper for ezxml_new() that strdup()s name
#define ezxml_new_d(name) ezxml_set_flag(ezxml_new(strdup(name)), EZXML_NAMEM)
// Adds a child tag. off is the offset of the child tag relative to the start
// of the parent tag's character content. Returns the child tag.
DLL_EXPORT ezxml_t ezxml_add_child(ezxml_t xml, const char *name, size_t off);
// wrapper for ezxml_add_child() that strdup()s name
#define ezxml_add_child_d(xml, name, off) \
ezxml_set_flag(ezxml_add_child(xml, strdup(name), off), EZXML_NAMEM)
// sets the character content for the given tag and returns the tag
DLL_EXPORT ezxml_t ezxml_set_txt(ezxml_t xml, const char *txt);
// wrapper for ezxml_set_txt() that strdup()s txt
#define ezxml_set_txt_d(xml, txt) \
ezxml_set_flag(ezxml_set_txt(xml, strdup(txt)), EZXML_TXTM)
// Sets the given tag attribute or adds a new attribute if not found. A value
// of NULL will remove the specified attribute. Returns the tag given.
DLL_EXPORT ezxml_t ezxml_set_attr(ezxml_t xml, const char *name, const char *value);
// Wrapper for ezxml_set_attr() that strdup()s name/value. Value cannot be NULL
#define ezxml_set_attr_d(xml, name, value) \
ezxml_set_attr(ezxml_set_flag(xml, EZXML_DUP), strdup(name), strdup(value))
// sets a flag for the given tag and returns the tag
DLL_EXPORT ezxml_t ezxml_set_flag(ezxml_t xml, short flag);
// removes a tag along with its subtags without freeing its memory
DLL_EXPORT ezxml_t ezxml_cut(ezxml_t xml);
// inserts an existing tag into an ezxml structure
DLL_EXPORT ezxml_t ezxml_insert(ezxml_t xml, ezxml_t dest, size_t off);
// Moves an existing tag to become a subtag of dest at the given offset from
// the start of dest's character content. Returns the moved tag.
#define ezxml_move(xml, dest, off) ezxml_insert(ezxml_cut(xml), dest, off)
// removes a tag along with all its subtags
#define ezxml_remove(xml) ezxml_free(ezxml_cut(xml))
#ifdef __cplusplus
}
#endif
#endif // _EZXML_H
mapcache-rel-1-14-1/include/mapcache-config.h.in 0000664 0000000 0000000 00000001124 14653160677 0021337 0 ustar 00root root 0000000 0000000 #ifndef _MAPCACHE_CONFIG_H
#define _MAPCACHE_CONFIG_H
#cmakedefine USE_PIXMAN 1
#cmakedefine USE_FASTCGI 1
#cmakedefine USE_SQLITE 1
#cmakedefine USE_POSTGRESQL 1
#cmakedefine USE_BDB 1
#cmakedefine USE_LMDB 1
#cmakedefine USE_MEMCACHE 1
#cmakedefine USE_REDIS 1
#cmakedefine USE_TIFF 1
#cmakedefine USE_TIFF_WRITE 1
#cmakedefine USE_GEOTIFF 1
#cmakedefine USE_PCRE 1
#cmakedefine USE_PCRE2 1
#cmakedefine USE_MAPSERVER 1
#cmakedefine USE_RIAK 1
#cmakedefine USE_GDAL 1
#cmakedefine HAVE_STRNCASECMP 1
#cmakedefine HAVE_SYMLINK 1
#cmakedefine HAVE_STRPTIME 1
#cmakedefine HAVE_TIMEGM 1
#endif
mapcache-rel-1-14-1/include/mapcache-version.h.in 0000664 0000000 0000000 00000000526 14653160677 0021564 0 ustar 00root root 0000000 0000000 #ifndef _MAPCACHE_VERSION_H
#define _MAPCACHE_VERSION_H
#define MAPCACHE_VERSION_MAJOR @MAPCACHE_VERSION_MAJOR@
#define MAPCACHE_VERSION_MINOR @MAPCACHE_VERSION_MINOR@
#define MAPCACHE_VERSION_REV @MAPCACHE_VERSION_REVISION@
#define MAPCACHE_VERSION "@MAPCACHE_VERSION_STRING@"
#define MAPCACHE_VERSION_NUM @MAPCACHE_VERSION_NUM@
#endif
mapcache-rel-1-14-1/include/mapcache.h 0000664 0000000 0000000 00000162742 14653160677 0017505 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapCache
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
/*! \file mapcache.h
\brief global function and structure declarations
*/
#ifndef MAPCACHE_H_
#define MAPCACHE_H_
#include "mapcache-config.h"
#include "mapcache-version.h"
#include
#include
#include
#include "util.h"
#include "ezxml.h"
#include "errors.h"
#include
#include
#include
#define MAPCACHE_SUCCESS 0
#define MAPCACHE_FAILURE 1
#define MAPCACHE_TRUE 1
#define MAPCACHE_FALSE 0
#define MAPCACHE_TILESET_WRONG_SIZE 2
#define MAPCACHE_TILESET_WRONG_RESOLUTION 3
#define MAPCACHE_TILESET_WRONG_EXTENT 4
#define MAPCACHE_CACHE_MISS 5
#define MAPCACHE_FILE_LOCKED 6
#define MAPCACHE_CACHE_RELOAD 7
#define MAPCACHE_MAX_NUM_TILES 1000
#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;
typedef struct mapcache_image_format_mixed mapcache_image_format_mixed;
typedef struct mapcache_image_format_png mapcache_image_format_png;
typedef struct mapcache_image_format_png_q mapcache_image_format_png_q;
typedef struct mapcache_image_format_jpeg mapcache_image_format_jpeg;
typedef struct mapcache_image_format_raw mapcache_image_format_raw;
typedef struct mapcache_cfg mapcache_cfg;
typedef struct mapcache_tileset mapcache_tileset;
typedef struct mapcache_cache mapcache_cache;
typedef struct mapcache_source mapcache_source;
typedef struct mapcache_buffer mapcache_buffer;
typedef struct mapcache_tile mapcache_tile;
typedef struct mapcache_metatile mapcache_metatile;
typedef struct mapcache_feature_info mapcache_feature_info;
typedef struct mapcache_request_get_feature_info mapcache_request_get_feature_info;
typedef struct mapcache_map mapcache_map;
typedef struct mapcache_http_response mapcache_http_response;
typedef struct mapcache_http mapcache_http;
typedef struct mapcache_request mapcache_request;
typedef struct mapcache_request_image mapcache_request_image;
typedef struct mapcache_request_proxy mapcache_request_proxy;
typedef struct mapcache_request_get_capabilities mapcache_request_get_capabilities;
typedef struct mapcache_forwarding_rule mapcache_forwarding_rule;
typedef struct mapcache_request_get_tile mapcache_request_get_tile;
typedef struct mapcache_request_get_map mapcache_request_get_map;
typedef struct mapcache_service mapcache_service;
typedef struct mapcache_server_cfg mapcache_server_cfg;
typedef struct mapcache_image mapcache_image;
typedef struct mapcache_grid mapcache_grid;
typedef struct mapcache_grid_level mapcache_grid_level;
typedef struct mapcache_grid_link mapcache_grid_link;
typedef struct mapcache_rule mapcache_rule;
typedef struct mapcache_ruleset mapcache_ruleset;
typedef struct mapcache_context mapcache_context;
typedef struct mapcache_dimension mapcache_dimension;
typedef struct mapcache_requested_dimension mapcache_requested_dimension;
typedef struct mapcache_extent mapcache_extent;
typedef struct mapcache_extent_i mapcache_extent_i;
typedef struct mapcache_connection_pool mapcache_connection_pool;
typedef struct mapcache_locker mapcache_locker;
typedef enum {
MAPCACHE_DIMENSION_VALUES,
MAPCACHE_DIMENSION_REGEX,
MAPCACHE_DIMENSION_POSTGRESQL,
MAPCACHE_DIMENSION_SQLITE,
MAPCACHE_DIMENSION_ELASTICSEARCH
} mapcache_dimension_type;
typedef enum {
MAPCACHE_DIMENSION_ASSEMBLY_NONE,
MAPCACHE_DIMENSION_ASSEMBLY_STACK,
MAPCACHE_DIMENSION_ASSEMBLY_ANIMATE
} mapcache_dimension_assembly_type;
/** \defgroup utility Utility */
/** @{ */
struct mapcache_extent {
double minx;
double miny;
double maxx;
double maxy;
};
struct mapcache_extent_i {
int minx;
int miny;
int maxx;
int maxy;
};
#ifdef __GNUC__
/** Tag a function to have printf() formatting */
#define MAPCACHE_PRINT_FUNC_FORMAT(format_idx, arg_idx) \
__attribute__((__format__(__printf__, format_idx, arg_idx)))
#else
#define MAPCACHE_PRINT_FUNC_FORMAT(format_idx, arg_idx)
#endif
mapcache_image *mapcache_error_image(mapcache_context *ctx, int width, int height, char *msg);
/**
* \interface mapcache_context
* \brief structure passed to most mapcache functions to abstract common functions
*/
struct mapcache_context {
/**
* \brief indicate that an error has happened
* \memberof mapcache_context
* \param c
* \param code the error code
* \param message human readable message of what happened
*/
void (*set_error)(mapcache_context *ctx, int code, char *message, ...) MAPCACHE_PRINT_FUNC_FORMAT(3, 4);
void (*set_exception)(mapcache_context *ctx, char *key, char *message, ...) MAPCACHE_PRINT_FUNC_FORMAT(3, 4);
/**
* \brief query context to know if an error has occurred
* \memberof mapcache_context
*/
int (*get_error)(mapcache_context * ctx);
/**
* \brief get human readable message for the error
* \memberof mapcache_context
*/
char* (*get_error_message)(mapcache_context * ctx);
/**
* \brief get human readable message for the error
* \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
*/
void (*push_errors)(mapcache_context * ctx, void *error);
/**
* \brief log a message
* \memberof mapcache_context
*/
void (*log)(mapcache_context *ctx, mapcache_log_level level, char *message, ...);
const char* (*get_instance_id)(mapcache_context * ctx);
mapcache_context* (*clone)(mapcache_context *ctx);
apr_pool_t *pool;
mapcache_connection_pool *connection_pool;
char *_contenttype;
char *_errmsg;
int _errcode;
mapcache_cfg *config;
mapcache_service *service;
apr_table_t *exceptions;
int supports_redirects;
apr_table_t *headers_in;
};
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;
#define GC_HAS_ERROR(ctx) (((mapcache_context*)ctx)->_errcode > 0)
/**
* \brief autoexpanding buffer that allocates memory from a pool
* \sa mapcache_buffer_create()
* \sa mapcache_buffer_append()
*
*/
struct mapcache_buffer {
void* buf; /**< pointer to the actual data contained in buffer */
size_t size; /**< number of bytes actually used in the buffer */
size_t avail; /**< number of bytes allocated */
apr_pool_t* pool; /**< apache pool to allocate from */
};
/* in buffer.c */
/**
* \brief create and initialize a mapcache_buffer
* \memberof mapcache_buffer
* \param initialStorage the initial size that should be allocated in the buffer.
* defaults to #INITIAL_BUFFER_SIZE.
* \param pool the pool from which to allocate memory.
*/
mapcache_buffer *mapcache_buffer_create(size_t initialStorage, apr_pool_t* pool);
/**
* \brief append data
* \memberof mapcache_buffer
* \param buffer
* \param len the lenght of the data to append.
* \param data the data to append
*/
int mapcache_buffer_append(mapcache_buffer *buffer, size_t len, void *data);
/** @} */
/** \defgroup source Sources */
/** @{ */
typedef enum {
MAPCACHE_SOURCE_WMS,
MAPCACHE_SOURCE_MAPSERVER,
MAPCACHE_SOURCE_DUMMY,
MAPCACHE_SOURCE_GDAL,
MAPCACHE_SOURCE_FALLBACK
} mapcache_source_type;
/**\interface mapcache_source
* \brief a source of data that can return image data
*/
struct mapcache_source {
char *name; /**< the key this source can be referenced by */
mapcache_extent data_extent; /**< extent in which this source can produce data */
mapcache_source_type type;
apr_table_t *metadata;
unsigned int retry_count;
double retry_delay;
apr_array_header_t *info_formats;
/**
* \brief get the data for the metatile
*
* sets the mapcache_metatile::tile::data for the given tile
*/
void (*_render_map)(mapcache_context *ctx, mapcache_source *psource, mapcache_map *map);
void (*_query_info)(mapcache_context *ctx, mapcache_source *psource, mapcache_feature_info *fi);
void (*configuration_parse_xml)(mapcache_context *ctx, ezxml_t xml, mapcache_source * source, mapcache_cfg *config);
void (*configuration_check)(mapcache_context *ctx, mapcache_cfg *cfg, mapcache_source * source);
};
mapcache_http* mapcache_http_configuration_parse_xml(mapcache_context *ctx,ezxml_t node);
mapcache_http* mapcache_http_clone(mapcache_context *ctx, mapcache_http *orig);
struct mapcache_http {
char *url; /**< the base url to request */
apr_table_t *headers; /**< additional headers to add to the http request, eg, Referer */
char *post_body;
size_t post_len;
int connection_timeout;
int timeout;
/* TODO: authentication */
};
/** \defgroup cache Caches */
/** @{ */
typedef enum {
MAPCACHE_CACHE_DISK
,MAPCACHE_CACHE_REST
,MAPCACHE_CACHE_MEMCACHE
,MAPCACHE_CACHE_SQLITE
,MAPCACHE_CACHE_BDB
,MAPCACHE_CACHE_TC
,MAPCACHE_CACHE_TIFF
,MAPCACHE_CACHE_COMPOSITE
,MAPCACHE_CACHE_COUCHBASE
,MAPCACHE_CACHE_RIAK
,MAPCACHE_CACHE_REDIS
,MAPCACHE_CACHE_LMDB
} mapcache_cache_type;
/** \interface mapcache_cache
* \brief a place to cache a mapcache_tile
*/
struct mapcache_cache {
char *name; /**< key this cache is referenced by */
mapcache_cache_type type;
apr_table_t *metadata;
unsigned int retry_count;
double retry_delay;
/**
* get tile content from cache
* \returns MAPCACHE_SUCCESS if the data was correctly loaded from the cache
* \returns MAPCACHE_FAILURE if the file exists but contains no data
* \returns MAPCACHE_CACHE_MISS if the file does not exist on the cache
* \memberof mapcache_cache
*/
int (*_tile_get)(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile * tile);
/**
* delete tile from cache
*
* \memberof mapcache_cache
*/
void (*_tile_delete)(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile * tile);
int (*_tile_exists)(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile * tile);
/**
* set tile content to cache
* \memberof mapcache_cache
*/
void (*_tile_set)(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile * tile);
void (*_tile_multi_set)(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tiles, int ntiles);
void (*configuration_parse_xml)(mapcache_context *ctx, ezxml_t xml, mapcache_cache * cache, mapcache_cfg *config);
void (*configuration_post_config)(mapcache_context *ctx, mapcache_cache * cache, mapcache_cfg *config);
void (*child_init)(mapcache_context *ctx, mapcache_cache *cache, apr_pool_t *pchild);
};
MS_DLL_EXPORT int mapcache_cache_tile_get(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile);
void mapcache_cache_tile_delete(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile);
MS_DLL_EXPORT int mapcache_cache_tile_exists(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile);
MS_DLL_EXPORT void mapcache_cache_tile_set(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile);
void mapcache_cache_tile_multi_set(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tiles, int ntiles);
MS_DLL_EXPORT void mapcache_cache_child_init(mapcache_context *ctx, mapcache_cfg *config, apr_pool_t *pchild);
static inline void mapcache_cache_child_init_noop(mapcache_context *ctx, mapcache_cache *cache, apr_pool_t *pchild) {
};
/**
* \memberof mapcache_cache_sqlite
*/
mapcache_cache* mapcache_cache_sqlite_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_mbtiles_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_bdb
*/
mapcache_cache *mapcache_cache_bdb_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_lmdb
*/
mapcache_cache *mapcache_cache_lmdb_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_memcache
*/
mapcache_cache* mapcache_cache_memcache_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_couchbase
*/
mapcache_cache* mapcache_cache_couchbase_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_tc
*/
mapcache_cache* mapcache_cache_tc_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_riak
*/
mapcache_cache* mapcache_cache_riak_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_redis
*/
mapcache_cache* mapcache_cache_redis_create(mapcache_context* ctx);
/** @} */
typedef enum {
MAPCACHE_REQUEST_UNKNOWN,
MAPCACHE_REQUEST_GET_TILE,
MAPCACHE_REQUEST_GET_MAP,
MAPCACHE_REQUEST_GET_CAPABILITIES,
MAPCACHE_REQUEST_GET_FEATUREINFO,
MAPCACHE_REQUEST_PROXY
} mapcache_request_type;
typedef enum {
MAPCACHE_GETMAP_ERROR,
MAPCACHE_GETMAP_ASSEMBLE,
MAPCACHE_GETMAP_FORWARD
} mapcache_getmap_strategy;
typedef enum {
MAPCACHE_RESAMPLE_NEAREST,
MAPCACHE_RESAMPLE_BILINEAR
} mapcache_resample_mode;
/**
* \brief a request sent by a client
*/
struct mapcache_request {
mapcache_request_type type;
mapcache_service *service;
};
struct mapcache_request_image {
mapcache_request request;
mapcache_image_format *format;
};
struct mapcache_request_get_tile {
mapcache_request_image image_request;
/**
* a list of tiles requested by the client
*/
mapcache_tile **tiles;
/**
* the number of tiles requested by the client.
* If more than one, and merging is enabled,
* the supplied tiles will be merged together
* before being returned to the client
*/
int ntiles;
int allow_redirect;
};
struct mapcache_http_response {
mapcache_buffer *data;
apr_table_t *headers;
long code;
apr_time_t mtime;
};
struct mapcache_map {
mapcache_tileset *tileset;
mapcache_grid_link *grid_link;
apr_array_header_t *dimensions;
mapcache_buffer *encoded_data;
mapcache_image *raw_image;
int nodata; /**< \sa mapcache_tile::nodata */
int width, height;
mapcache_extent extent;
apr_time_t mtime; /**< last modification time */
int expires; /**< time in seconds after which the tile should be rechecked for validity */
};
struct mapcache_feature_info {
mapcache_map map;
int i,j;
char *format;
mapcache_buffer *data;
};
struct mapcache_request_get_feature_info {
mapcache_request request;
mapcache_feature_info *fi;
};
struct mapcache_request_get_map {
mapcache_request_image image_request;
mapcache_map **maps;
int nmaps;
mapcache_getmap_strategy getmap_strategy;
mapcache_resample_mode resample_mode;
};
struct mapcache_request_get_capabilities {
mapcache_request request;
/**
* the body of the capabilities
*/
char *capabilities;
/**
* the mime type
*/
char *mime_type;
};
struct mapcache_forwarding_rule {
char *name;
mapcache_http *http;
apr_array_header_t *match_params; /* actually those are mapcache_dimensions */
int append_pathinfo;
size_t max_post_len;
};
struct mapcache_request_proxy {
mapcache_request request;
mapcache_forwarding_rule *rule;
apr_table_t *params;
apr_table_t *headers;
const char *pathinfo;
char *post_buf;
size_t post_len;
};
/** \defgroup services Services*/
/** @{ */
#define MAPCACHE_SERVICES_COUNT 8
typedef enum {
MAPCACHE_SERVICE_TMS=0, MAPCACHE_SERVICE_WMTS,
MAPCACHE_SERVICE_DEMO, MAPCACHE_SERVICE_GMAPS, MAPCACHE_SERVICE_KML,
MAPCACHE_SERVICE_VE, MAPCACHE_SERVICE_MAPGUIDE, MAPCACHE_SERVICE_WMS
} mapcache_service_type;
#define MAPCACHE_UNITS_COUNT 3
typedef enum {
MAPCACHE_UNIT_METERS=0, MAPCACHE_UNIT_DEGREES, MAPCACHE_UNIT_FEET
} mapcache_unit;
/* defined in util.c*/
extern const double mapcache_meters_per_unit[MAPCACHE_UNITS_COUNT];
/** \interface mapcache_service
* \brief a standard service (eg WMS, TMS)
*/
struct mapcache_service {
char *name;
mapcache_service_type type;
/**
* the pathinfo prefix of the url that routes to this service
* eg, for accessing a wms service on http://host/mapcache/mywmsservice? ,
* url_prefix would take the value "mywmsservice"
*/
char *url_prefix;
/**
* \brief allocates and populates a mapcache_request corresponding to the parameters received
*/
void (*parse_request)(mapcache_context *ctx, mapcache_service *service, mapcache_request **request, const char *path_info, apr_table_t *params, mapcache_cfg * config);
/**
* \param request the received request (should be of type MAPCACHE_REQUEST_CAPABILITIES
* \param url the full url at which the service is available
*/
void (*create_capabilities_response)(mapcache_context *ctx, mapcache_request_get_capabilities *request, char *url, char *path_info, mapcache_cfg *config);
/**
* parse advanced configuration options for the selected service
*/
void (*configuration_parse_xml)(mapcache_context *ctx, ezxml_t xml, mapcache_service * service, mapcache_cfg *config);
void (*format_error)(mapcache_context *ctx, mapcache_service * service, char *err_msg,
char **err_body, apr_table_t *headers);
};
/**
* \brief create and initialize a mapcache_service_wms
* \memberof mapcache_service_wms
*/
mapcache_service* mapcache_service_wms_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_ve
* \memberof mapcache_service_ve
*/
mapcache_service* mapcache_service_ve_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_mapguide
* \memberof mapcache_service_mapguide
*/
mapcache_service* mapcache_service_mapguide_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_gmaps
* \memberof mapcache_service_gmaps
*/
mapcache_service* mapcache_service_gmaps_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_kml
* \memberof mapcache_service_kml
*/
mapcache_service* mapcache_service_kml_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_tms
* \memberof mapcache_service_tms
*/
mapcache_service* mapcache_service_tms_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_wmts
* \memberof mapcache_service_wtms
*/
mapcache_service* mapcache_service_wmts_create(mapcache_context *ctx);
/**
* \brief create and initialize a mapcache_service_demo
* \memberof mapcache_service_demo
*/
mapcache_service* mapcache_service_demo_create(mapcache_context *ctx);
/**
* \brief return the request that corresponds to the given url
*/
MS_DLL_EXPORT void mapcache_service_dispatch_request(mapcache_context *ctx,
mapcache_request **request,
char *pathinfo,
apr_table_t *params,
mapcache_cfg *config);
/**
* \brief return the number of enabled/configured services
*/
MS_DLL_EXPORT int mapcache_config_services_enabled(mapcache_context *ctx, mapcache_cfg *config);
/** @} */
/** \defgroup image Image Data Handling */
/** @{ */
typedef enum {
GC_UNKNOWN, GC_PNG, GC_JPEG, GC_RAW
} mapcache_image_format_type;
typedef enum {
MC_EMPTY_UNKNOWN, MC_EMPTY_YES, MC_EMPTY_NO
} mapcache_image_blank_type;
typedef enum {
MC_ALPHA_UNKNOWN, MC_ALPHA_YES, MC_ALPHA_NO
} mapcache_image_alpha_type;
/**\class mapcache_image
* \brief representation of an RGBA image
*
* to access a pixel at position x,y, you should use the #GET_IMG_PIXEL macro
*/
struct mapcache_image {
unsigned char *data; /**< pointer to the beginning of image data, stored in rgba order */
size_t w; /**< width of the image */
size_t h; /**< height of the image */
size_t stride; /**< stride of an image row */
mapcache_image_blank_type is_blank;
mapcache_image_alpha_type has_alpha;
};
/** \def GET_IMG_PIXEL
* return the address of a pixel
* \param y the row
* \param x the column
* \param img the mapcache_image
* \returns a pointer to the pixel
*/
#define GET_IMG_PIXEL(img,x,y) (&((img).data[(y)*(img).stride + (x)*4]))
/**
* \brief initialize a new mapcache_image
*/
mapcache_image* mapcache_image_create(mapcache_context *ctx);
mapcache_image* mapcache_image_create_with_data(mapcache_context *ctx, int width, int height);
void mapcache_image_copy_resampled_nearest(mapcache_context *ctx, mapcache_image *src, mapcache_image *dst,
double off_x, double off_y, double scale_x, double scale_y);
void mapcache_image_copy_resampled_bilinear(mapcache_context *ctx, mapcache_image *src, mapcache_image *dst,
double off_x, double off_y, double scale_x, double scale_y, int reflect_edges);
/**
* \brief merge two images
* \param base the imae to merge onto
* \param overlay the image to overlay onto
* \param ctx the context
* when finished, base will be modified and have overlay merged onto it
*/
void mapcache_image_merge(mapcache_context *ctx, mapcache_image *base, mapcache_image *overlay);
void mapcache_image_copy_resampled(mapcache_context *ctx, mapcache_image *src, mapcache_image *dst,
int srcX, int srcY, int srcW, int srcH,
int dstX, int dstY, int dstW, int dstH);
/**
* \brief split the given metatile into tiles
* \param mt the metatile to split
* \param r the context
*/
void mapcache_image_metatile_split(mapcache_context *ctx, mapcache_metatile *mt);
/**
* \brief check if given image is composed of a unique color
* \param image the mapcache_image to process
* \returns MAPCACHE_TRUE if the image contains a single color
* \returns MAPCACHE_FALSE if the image has more than one color
*/
int mapcache_image_blank_color(mapcache_image* image);
/**
* \brief check if image has some non opaque pixels
*/
int mapcache_image_has_alpha(mapcache_image *img, unsigned int cutoff);
void mapcache_image_fill(mapcache_context *ctx, mapcache_image *image, const unsigned char *fill_color);
/** @} */
/** \defgroup http HTTP Request handling*/
/** @{ */
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);
MS_DLL_EXPORT apr_table_t *mapcache_http_parse_param_string(mapcache_context *ctx, char *args);
/** @} */
/** \defgroup configuration Configuration*/
/** @{ */
typedef enum {
MAPCACHE_MODE_NORMAL,
MAPCACHE_MODE_MIRROR_COMBINED,
MAPCACHE_MODE_MIRROR_SPLIT
} mapcache_mode;
typedef enum {
MAPCACHE_LOCKER_DISK,
MAPCACHE_LOCKER_MEMCACHE,
MAPCACHE_LOCKER_FALLBACK
} mapcache_lock_mode;
typedef enum {
MAPCACHE_LOCK_AQUIRED,
MAPCACHE_LOCK_LOCKED,
MAPCACHE_LOCK_NOENT
} mapcache_lock_result;
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, void *lock);
void (*release_lock)(mapcache_context *ctx, mapcache_locker *self, void *lock);
void (*parse_xml)(mapcache_context *ctx, mapcache_locker *self, ezxml_t node);
mapcache_lock_mode type;
double timeout;
double retry_interval; /* time to wait before checking again on a lock, in seconds */
};
mapcache_locker* mapcache_locker_disk_create(mapcache_context *ctx);
mapcache_locker* mapcache_locker_memcache_create(mapcache_context *ctx);
mapcache_locker* mapcache_locker_fallback_create(mapcache_context *ctx);
void mapcache_config_parse_locker(mapcache_context *ctx, ezxml_t node, mapcache_locker **locker);
void mapcache_config_parse_locker_old(mapcache_context *ctx, ezxml_t doc, mapcache_cfg *config);
/**
* a configuration that will be served
*/
struct mapcache_cfg {
/**
* a list of services that will be responded to
*/
mapcache_service * services[MAPCACHE_SERVICES_COUNT];
/**
* hashtable containing configured mapcache_source%s
*/
apr_hash_t *sources;
/**
* hashtable containing configured mapcache_cache%s
*/
apr_hash_t *caches;
/**
* hashtable containing configured mapcache_tileset%s
*/
apr_hash_t *tilesets;
/**
* hashtable containing configured mapcache_image_format%s
*/
apr_hash_t *image_formats;
/**
* hashtable containing (pre)defined grids
*/
apr_hash_t *grids;
/**
* hashtable containing (pre)defined rulesets
*/
apr_hash_t *rulesets;
/**
* the format to use for some miscelaneaous operations:
* - creating an empty image
* - creating an error image
* - as a fallback when merging multiple tiles
*/
mapcache_image_format *default_image_format;
/**
* how should error messages be reported to the user
*/
mapcache_error_reporting reporting;
/**
* encoded empty (tranpsarent) image that will be returned to clients if cofigured
* to return blank images upon error
*/
mapcache_buffer *empty_image;
apr_table_t *metadata;
mapcache_locker *locker;
int threaded_fetching;
/* for fastcgi only */
int autoreload; /* should the modification time of the config file be recorded
and the file be reparsed if it is modified. */
mapcache_log_level loglevel; /* logging verbosity. Ignored for the apache module
as in that case the apache LogLevel directive is
used. */
mapcache_mode mode;
/* return 404 on potentially blocking operations (proxying, source getmaps,
locks on metatile waiting, ... Used for nginx module */
int non_blocking;
// Parameters for connection_pool:
// - cp_hmax defines the maximum number of open connections at the same time
// - cp_ttl defines the maximum amount of time in microseconds an unused connection is valid
int cp_hmax;
int cp_ttl;
};
/**
*
* @param filename
* @param config
* @param pool
* @return
*/
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);
MS_DLL_EXPORT mapcache_cfg* mapcache_configuration_create(apr_pool_t *pool);
mapcache_source* mapcache_configuration_get_source(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);
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);
mapcache_ruleset *mapcache_configuration_get_ruleset(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);
void mapcache_configuration_add_grid(mapcache_cfg *config, mapcache_grid *grid, const char * key);
void mapcache_configuration_add_ruleset(mapcache_cfg *config, mapcache_ruleset *ruleset, const char * key);
void mapcache_configuration_add_tileset(mapcache_cfg *config, mapcache_tileset *tileset, const char * key);
void mapcache_configuration_add_cache(mapcache_cfg *config, mapcache_cache *cache, const char * key);
/** @} */
/**
* \memberof mapcache_source
*/
void mapcache_source_init(mapcache_context *ctx, mapcache_source *source);
/**
* \memberof mapcache_source
*/
void mapcache_source_render_map(mapcache_context *ctx, mapcache_source *source, mapcache_map *map);
void mapcache_source_query_info(mapcache_context *ctx, mapcache_source *source,
mapcache_feature_info *fi);
/**
* \memberof mapcache_source_gdal
*/
mapcache_source* mapcache_source_gdal_create(mapcache_context *ctx);
/**
* \memberof mapcache_source_fallback
*/
mapcache_source* mapcache_source_fallback_create(mapcache_context *ctx);
/**
* \memberof mapcache_source_wms
*/
mapcache_source* mapcache_source_wms_create(mapcache_context *ctx);
/**
* \memberof mapcache_source_wms
*/
mapcache_source* mapcache_source_mapserver_create(mapcache_context *ctx);
mapcache_source* mapcache_source_dummy_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_disk
*/
mapcache_cache* mapcache_cache_disk_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_rest
*/
mapcache_cache* mapcache_cache_rest_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_s3_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_azure_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_google_create(mapcache_context *ctx);
/**
* \memberof mapcache_cache_tiff
*/
mapcache_cache* mapcache_cache_tiff_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_composite_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_fallback_create(mapcache_context *ctx);
mapcache_cache* mapcache_cache_multitier_create(mapcache_context *ctx);
/** \defgroup tileset Tilesets*/
/** @{ */
/**
* \brief Tile
* \sa mapcache_metatile
* \sa mapcache_tileset::metasize_x mapcache_tileset::metasize_x mapcache_tileset::metabuffer
*/
struct mapcache_tile {
mapcache_tileset *tileset; /**< the mapcache_tileset that corresponds to the tile*/
mapcache_grid_link *grid_link;
int x; /**< tile x index */
int y; /**< tile y index */
int z; /**< tile z index (zoom level) */
/**
* encoded image data for the tile.
* \sa mapcache_cache::tile_get()
* \sa mapcache_source::render_map()
* \sa mapcache_image_format
*/
mapcache_buffer *encoded_data;
char *redirect;
int allow_redirect;
mapcache_image *raw_image;
apr_time_t mtime; /**< last modification time */
int expires; /**< time in seconds after which the tile should be rechecked for validity */
apr_array_header_t *dimensions;
/**
* flag stating the tile is empty (i.e. fully transparent).
* if set, this indicates that there was no error per se, but that there was
* no way to get data back from the cache for this tile. This will happen for
* a tileset with no configured, for tiles that have not been preseeded.
* Tile assembling functions should look for this flag and ignore such a tile when
* compositing image data
*/
int nodata;
};
/**
* \brief MetaTile
* \extends mapcache_tile
*/
struct mapcache_metatile {
mapcache_map map;
int x,y,z;
int metasize_x, metasize_y;
int ntiles; /**< the number of mapcache_metatile::tiles contained in this metatile */
mapcache_tile *tiles; /**< the list of mapcache_tile s contained in this metatile */
};
struct mapcache_grid_level {
double resolution;
unsigned int maxx, maxy;
};
/**
* \brief mapcache_grid_origin
* determines at which extent extrema the tiles will originate from. Only
* BOTTOM_LEFT and TOP_LEFT are implemented
*/
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;
struct mapcache_grid {
char *name;
int nlevels;
char *srs;
apr_array_header_t *srs_aliases;
mapcache_extent extent;
mapcache_unit unit;
int tile_sx, tile_sy; /**= alpha_cutoff will be considered fully opaque */
};
mapcache_buffer* mapcache_empty_png_decode(mapcache_context *ctx, int width, int height, const unsigned char *hex_color, int *is_empty);
mapcache_image_format* mapcache_imageio_create_mixed_format(apr_pool_t *pool,
char *name, mapcache_image_format *transparent, mapcache_image_format *opaque, unsigned int alpha_cutoff);
struct mapcache_image_format_raw {
mapcache_image_format format;
};
mapcache_image_format* mapcache_imageio_create_raw_format(apr_pool_t *pool, char *name, char *extension, char *mime_type);
int mapcache_imageio_is_raw_tileset(mapcache_tileset *tileset);
/**\class mapcache_image_format_png_q
* \brief Quantized PNG format
* \extends mapcache_image_format_png
*/
struct mapcache_image_format_png_q {
mapcache_image_format_png format;
int ncolors; /**< number of colors used in quantization, 2-256 */
};
/**
* @param r
* @param buffer
* @return
*/
mapcache_image* _mapcache_imageio_png_decode(mapcache_context *ctx, mapcache_buffer *buffer);
void mapcache_image_create_empty(mapcache_context *ctx, mapcache_cfg *cfg);
/**
* @param r
* @param buffer
* @return
*/
void _mapcache_imageio_png_decode_to_image(mapcache_context *ctx, mapcache_buffer *buffer,
mapcache_image *image);
/**
* \brief create a format capable of creating RGBA png
* \memberof mapcache_image_format_png
* @param pool
* @param name
* @param compression the ZLIB compression to apply
* @return
*/
mapcache_image_format* mapcache_imageio_create_png_format(apr_pool_t *pool, char *name, mapcache_compression_type compression);
/**
* \brief create a format capable of creating quantized png
* \memberof mapcache_image_format_png_q
* @param pool
* @param name
* @param compression the ZLIB compression to apply
* @param ncolors the number of colors to quantize with
* @return
*/
mapcache_image_format* mapcache_imageio_create_png_q_format(apr_pool_t *pool, char *name, mapcache_compression_type compression, int ncolors);
/** @} */
/**\defgroup imageio_jpg JPEG Image IO
* \ingroup imageio */
/** @{ */
/**\class mapcache_image_format_jpeg
* \brief JPEG image format
* \extends mapcache_image_format
*/
struct mapcache_image_format_jpeg {
mapcache_image_format format;
int quality; /**< JPEG quality, 1-100 */
mapcache_photometric photometric;
mapcache_optimization optimize;
};
mapcache_image_format* mapcache_imageio_create_jpeg_format(apr_pool_t *pool, char *name, int quality,
mapcache_photometric photometric, mapcache_optimization optimize);
/**
* @param r
* @param buffer
* @return
*/
mapcache_image* _mapcache_imageio_jpeg_decode(mapcache_context *ctx, mapcache_buffer *buffer);
/**
* @param r
* @param buffer
* @return
*/
void _mapcache_imageio_jpeg_decode_to_image(mapcache_context *ctx, mapcache_buffer *buffer,
mapcache_image *image);
/** @} */
/**
* \brief lookup the first few bytes of a buffer to check for a known image format
*/
mapcache_image_format_type mapcache_imageio_header_sniff(mapcache_context *ctx, mapcache_buffer *buffer);
/**
* \brief lookup the first few bytes of a buffer to check for alpha channel
*/
mapcache_image_alpha_type mapcache_imageio_alpha_sniff(mapcache_context *ctx, mapcache_buffer *buffer);
/**
* \brief checks if the given buffer is a recognized image format
*/
int mapcache_imageio_is_valid_format(mapcache_context *ctx, mapcache_buffer *buffer);
/**
* decodes given buffer
*/
mapcache_image* mapcache_imageio_decode(mapcache_context *ctx, mapcache_buffer *buffer);
/**
* decodes given buffer to an allocated image
*/
void mapcache_imageio_decode_to_image(mapcache_context *ctx, mapcache_buffer *buffer, mapcache_image *image);
/** @} */
typedef struct {
double start;
double end;
double resolution;
} mapcache_interval;
struct mapcache_requested_dimension {
mapcache_dimension *dimension;
char *requested_value;
char *cached_value;
apr_array_header_t *cached_entries_for_value;
};
void mapcache_tile_set_cached_dimension(mapcache_context *ctx, mapcache_tile *tile, const char *name, const char *value);
void mapcache_map_set_cached_dimension(mapcache_context *ctx, mapcache_map *map, const char *name, const char *value);
void mapcache_tile_set_requested_dimension(mapcache_context *ctx, mapcache_tile *tile, const char *name, const char *value);
void mapcache_map_set_requested_dimension(mapcache_context *ctx, mapcache_map *map, const char *name, const char *value);
MS_DLL_EXPORT void mapcache_set_requested_dimension(mapcache_context *ctx, apr_array_header_t *dimensions, const char *name, const char *value);
MS_DLL_EXPORT void mapcache_set_cached_dimension(mapcache_context *ctx, apr_array_header_t *dimensions, const char *name, const char *value);
MS_DLL_EXPORT apr_array_header_t *mapcache_requested_dimensions_clone(apr_pool_t *pool, apr_array_header_t *src);
struct mapcache_dimension {
mapcache_dimension_type type;
const char *class_name;
int isTime;
int wms_querybymap_minzoom;
char *name;
char *unit;
apr_table_t *metadata;
char *default_value;
/**
* \brief return the list of dimension values that match the requested entry
*/
apr_array_header_t* (*_get_entries_for_value)(mapcache_context *ctx, mapcache_dimension *dimension, const char *value,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
/**
* \brief return the list of dimension values that match the requested time range
*/
apr_array_header_t* (*_get_entries_for_time_range)(mapcache_context *ctx, mapcache_dimension *dimension, const char *value,
time_t start, time_t end,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
/**
* \brief return all possible values
*/
apr_array_header_t* (*get_all_entries)(mapcache_context *ctx, mapcache_dimension *dimension,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
/**
* \brief return all possible values formatted in a way compatible with OGC capabilities element
*/
apr_array_header_t* (*get_all_ogc_formatted_entries)(mapcache_context *ctx, mapcache_dimension *dimension,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
/**
* \brief return all value to override default value
*/
apr_array_header_t* (*get_default_value)(mapcache_context *ctx, mapcache_dimension *dimension,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
/**
* \brief parse the value given in the configuration
*/
void (*configuration_parse_xml)(mapcache_context *context, mapcache_dimension *dim, ezxml_t node);
};
mapcache_dimension* mapcache_dimension_values_create(mapcache_context *ctx, apr_pool_t *pool);
mapcache_dimension* mapcache_dimension_sqlite_create(mapcache_context *ctx, apr_pool_t *pool);
mapcache_dimension* mapcache_dimension_postgresql_create(mapcache_context *ctx, apr_pool_t *pool);
mapcache_dimension* mapcache_dimension_regex_create(mapcache_context *ctx, apr_pool_t *pool);
mapcache_dimension* mapcache_dimension_time_create(mapcache_context *ctx, apr_pool_t *pool);
mapcache_dimension* mapcache_dimension_elasticsearch_create(mapcache_context *ctx, apr_pool_t *pool);
MS_DLL_EXPORT apr_array_header_t* mapcache_dimension_get_entries_for_value(mapcache_context *ctx, mapcache_dimension *dimension, const char *value,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
apr_array_header_t* mapcache_dimension_time_get_entries_for_value(mapcache_context *ctx, mapcache_dimension *dimension, const char *value,
mapcache_tileset *tileset, mapcache_extent *extent, mapcache_grid *grid);
int mapcache_is_axis_inverted(const char *srs);
typedef struct mapcache_pooled_connection_container mapcache_pooled_connection_container;
typedef struct mapcache_pooled_connection mapcache_pooled_connection;
typedef struct mapcache_pooled_connection_private_data mapcache_pooled_connection_private_data;
struct mapcache_pooled_connection {
mapcache_pooled_connection_private_data *private;
void *connection;
};
typedef void (*mapcache_connection_constructor)(mapcache_context *ctx, void **connection, void *params);
typedef void (*mapcache_connection_destructor)(void *connection);
MS_DLL_EXPORT apr_status_t mapcache_connection_pool_create(mapcache_cfg *cfg, 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,
void *params);
void mapcache_connection_pool_invalidate_connection(mapcache_context *ctx, mapcache_pooled_connection *connection);
void mapcache_connection_pool_release_connection(mapcache_context *ctx, mapcache_pooled_connection *connection);
#endif /* MAPCACHE_H_ */
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/include/mapcache_services.h 0000664 0000000 0000000 00000011334 14653160677 0021376 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapCache
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2016 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
/*! \file mapcache_services.h
\brief structure declarations for supported services
*/
#ifndef MAPCACHE_SERVICES_H_
#define MAPCACHE_SERVICES_H_
#include "mapcache.h"
/** \addtogroup services */
/** @{ */
typedef struct mapcache_request_get_capabilities_wmts mapcache_request_get_capabilities_wmts;
typedef struct mapcache_service_wmts mapcache_service_wmts;
struct mapcache_request_get_capabilities_wmts {
mapcache_request_get_capabilities request;
};
/**\class mapcache_service_wmts
* \brief a WMTS service
* \implements mapcache_service
*/
struct mapcache_service_wmts {
mapcache_service service;
};
typedef struct mapcache_service_wms mapcache_service_wms;
typedef struct mapcache_request_get_capabilities_wms mapcache_request_get_capabilities_wms;
struct mapcache_request_get_capabilities_wms {
mapcache_request_get_capabilities request;
};
/**\class mapcache_service_wms
* \brief an OGC WMS service
* \implements mapcache_service
*/
struct mapcache_service_wms {
mapcache_service service;
int maxsize;
apr_array_header_t *forwarding_rules;
mapcache_getmap_strategy getmap_strategy;
mapcache_resample_mode resample_mode;
mapcache_image_format *getmap_format;
int allow_format_override; /* can the client specify which image format should be returned */
};
typedef struct mapcache_service_ve mapcache_service_ve;
/**\class mapcache_service_ve
* \brief a virtualearth service
* \implements mapcache_service
*/
struct mapcache_service_ve {
mapcache_service service;
};
typedef struct mapcache_service_gmaps mapcache_service_gmaps;
typedef struct mapcache_service_tms mapcache_service_tms;
typedef struct mapcache_request_get_capabilities_tms mapcache_request_get_capabilities_tms;
/**\class mapcache_service_tms
* \brief a TMS service
* \implements mapcache_service
*/
struct mapcache_service_tms {
mapcache_service service;
int reverse_y;
};
struct mapcache_request_get_capabilities_tms {
mapcache_request_get_capabilities request;
mapcache_tileset *tileset;
mapcache_grid_link *grid_link;
char *version;
};
typedef struct mapcache_service_mapguide mapcache_service_mapguide;
struct mapcache_service_mapguide {
mapcache_service service;
int rows_per_folder;
int cols_per_folder;
};
typedef struct mapcache_service_kml mapcache_service_kml;
typedef struct mapcache_request_get_capabilities_kml mapcache_request_get_capabilities_kml;
struct mapcache_request_get_capabilities_kml {
mapcache_request_get_capabilities request;
mapcache_tile *tile;
mapcache_tileset *tileset;
mapcache_grid_link *grid;
};
/**\class mapcache_service_kml
* \brief a KML superoverlay service
* \implements mapcache_service
*/
struct mapcache_service_kml {
mapcache_service service;
};
typedef struct mapcache_request_get_capabilities_demo mapcache_request_get_capabilities_demo;
typedef struct mapcache_service_demo mapcache_service_demo;
/**
* the capabilities request for a specific service, to be able to create
* demo pages specific to a given service
*/
struct mapcache_request_get_capabilities_demo {
mapcache_request_get_capabilities request;
mapcache_service *service;
};
/**\class mapcache_service_demo
* \brief a demo service
* \implements mapcache_service
*/
struct mapcache_service_demo {
mapcache_service service;
};
#endif /*MAPCACHE_SERVICES_H*/
mapcache-rel-1-14-1/include/util.h 0000664 0000000 0000000 00000006602 14653160677 0016711 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include
#include
#ifndef UTIL_H_
#define UTIL_H_
#define MAPCACHE_MAX(a,b) (((a)>(b))?(a):(b))
#define MAPCACHE_MIN(a,b) (((a)<(b))?(a):(b))
#ifndef APR_ARRAY_IDX
#define APR_ARRAY_IDX(ary,i,type) (((type *)(ary)->elts)[i])
#endif
#ifndef APR_ARRAY_PUSH
#define APR_ARRAY_PUSH(ary,type) (*((type *)apr_array_push(ary)))
#endif
#if APR_MAJOR_VERSION < 1 || (APR_MAJOR_VERSION < 2 && APR_MINOR_VERSION < 3)
/**
* Create a new table whose contents are deep copied from the given
* table. A deep copy operation copies all fields, and makes copies
* of dynamically allocated memory pointed to by the fields.
* @param p The pool to allocate the new table out of
* @param t The table to clone
* @return A deep copy of the table passed in
*/
APR_DECLARE(apr_table_t *) apr_table_clone(apr_pool_t *p,
const apr_table_t *t);
#endif
#if APR_MAJOR_VERSION < 1
#ifndef APR_FOPEN_READ
#define APR_FOPEN_READ APR_READ
#endif
#ifndef APR_FOPEN_BUFFERED
#define APR_FOPEN_BUFFERED APR_BUFFERED
#endif
#ifndef APR_FOPEN_BINARY
#define APR_FOPEN_BINARY APR_BINARY
#endif
#ifndef APR_FOPEN_CREATE
#define APR_FOPEN_CREATE APR_CREATE
#endif
#ifndef APR_FOPEN_WRITE
#define APR_FOPEN_WRITE APR_WRITE
#endif
#ifndef APR_FOPEN_SHARELOCK
#define APR_FOPEN_SHARELOCK APR_SHARELOCK
#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 */
};
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 /* for gettimeofday() */
# define mctimeval timeval
# define mapcache_gettimeofday(t,u) gettimeofday(t,u)
#endif
#endif /* UTIL_H_ */
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/ 0000775 0000000 0000000 00000000000 14653160677 0014702 5 ustar 00root root 0000000 0000000 mapcache-rel-1-14-1/lib/axisorder.c 0000664 0000000 0000000 00000054403 14653160677 0017054 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: Axis lookup table
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
static struct axisOrientationEpsgCodes_s {
int code;
} axisOrientationEpsgCodes[] = {
{ 4326 },
{ 4258 },
{ 31466 },
{ 31467 },
{ 31468 },
{ 31469 },
{ 2166 },
{ 2167 },
{ 2168 },
{ 2036 },
{ 2044 },
{ 2045 },
{ 2065 },
{ 2081 },
{ 2082 },
{ 2083 },
{ 2085 },
{ 2086 },
{ 2091 },
{ 2092 },
{ 2093 },
{ 2096 },
{ 2097 },
{ 2098 },
{ 2105 },
{ 2106 },
{ 2107 },
{ 2108 },
{ 2109 },
{ 2110 },
{ 2111 },
{ 2112 },
{ 2113 },
{ 2114 },
{ 2115 },
{ 2116 },
{ 2117 },
{ 2118 },
{ 2119 },
{ 2120 },
{ 2121 },
{ 2122 },
{ 2123 },
{ 2124 },
{ 2125 },
{ 2126 },
{ 2127 },
{ 2128 },
{ 2129 },
{ 2130 },
{ 2131 },
{ 2132 },
{ 2169 },
{ 2170 },
{ 2171 },
{ 2172 },
{ 2173 },
{ 2174 },
{ 2175 },
{ 2176 },
{ 2177 },
{ 2178 },
{ 2179 },
{ 2180 },
{ 2193 },
{ 2199 },
{ 2200 },
{ 2206 },
{ 2207 },
{ 2208 },
{ 2209 },
{ 2210 },
{ 2211 },
{ 2212 },
{ 2319 },
{ 2320 },
{ 2321 },
{ 2322 },
{ 2323 },
{ 2324 },
{ 2325 },
{ 2326 },
{ 2327 },
{ 2328 },
{ 2329 },
{ 2330 },
{ 2331 },
{ 2332 },
{ 2333 },
{ 2334 },
{ 2335 },
{ 2336 },
{ 2337 },
{ 2338 },
{ 2339 },
{ 2340 },
{ 2341 },
{ 2342 },
{ 2343 },
{ 2344 },
{ 2345 },
{ 2346 },
{ 2347 },
{ 2348 },
{ 2349 },
{ 2350 },
{ 2351 },
{ 2352 },
{ 2353 },
{ 2354 },
{ 2355 },
{ 2356 },
{ 2357 },
{ 2358 },
{ 2359 },
{ 2360 },
{ 2361 },
{ 2362 },
{ 2363 },
{ 2364 },
{ 2365 },
{ 2366 },
{ 2367 },
{ 2368 },
{ 2369 },
{ 2370 },
{ 2371 },
{ 2372 },
{ 2373 },
{ 2374 },
{ 2375 },
{ 2376 },
{ 2377 },
{ 2378 },
{ 2379 },
{ 2380 },
{ 2381 },
{ 2382 },
{ 2383 },
{ 2384 },
{ 2385 },
{ 2386 },
{ 2387 },
{ 2388 },
{ 2389 },
{ 2390 },
{ 2391 },
{ 2392 },
{ 2393 },
{ 2394 },
{ 2395 },
{ 2396 },
{ 2397 },
{ 2398 },
{ 2399 },
{ 2400 },
{ 2401 },
{ 2402 },
{ 2403 },
{ 2404 },
{ 2405 },
{ 2406 },
{ 2407 },
{ 2408 },
{ 2409 },
{ 2410 },
{ 2411 },
{ 2412 },
{ 2413 },
{ 2414 },
{ 2415 },
{ 2416 },
{ 2417 },
{ 2418 },
{ 2419 },
{ 2420 },
{ 2421 },
{ 2422 },
{ 2423 },
{ 2424 },
{ 2425 },
{ 2426 },
{ 2427 },
{ 2428 },
{ 2429 },
{ 2430 },
{ 2431 },
{ 2432 },
{ 2433 },
{ 2434 },
{ 2435 },
{ 2436 },
{ 2437 },
{ 2438 },
{ 2439 },
{ 2440 },
{ 2441 },
{ 2442 },
{ 2443 },
{ 2444 },
{ 2445 },
{ 2446 },
{ 2447 },
{ 2448 },
{ 2449 },
{ 2450 },
{ 2451 },
{ 2452 },
{ 2453 },
{ 2454 },
{ 2455 },
{ 2456 },
{ 2457 },
{ 2458 },
{ 2459 },
{ 2460 },
{ 2461 },
{ 2462 },
{ 2463 },
{ 2464 },
{ 2465 },
{ 2466 },
{ 2467 },
{ 2468 },
{ 2469 },
{ 2470 },
{ 2471 },
{ 2472 },
{ 2473 },
{ 2474 },
{ 2475 },
{ 2476 },
{ 2477 },
{ 2478 },
{ 2479 },
{ 2480 },
{ 2481 },
{ 2482 },
{ 2483 },
{ 2484 },
{ 2485 },
{ 2486 },
{ 2487 },
{ 2488 },
{ 2489 },
{ 2490 },
{ 2491 },
{ 2492 },
{ 2493 },
{ 2494 },
{ 2495 },
{ 2496 },
{ 2497 },
{ 2498 },
{ 2499 },
{ 2500 },
{ 2501 },
{ 2502 },
{ 2503 },
{ 2504 },
{ 2505 },
{ 2506 },
{ 2507 },
{ 2508 },
{ 2509 },
{ 2510 },
{ 2511 },
{ 2512 },
{ 2513 },
{ 2514 },
{ 2515 },
{ 2516 },
{ 2517 },
{ 2518 },
{ 2519 },
{ 2520 },
{ 2521 },
{ 2522 },
{ 2523 },
{ 2524 },
{ 2525 },
{ 2526 },
{ 2527 },
{ 2528 },
{ 2529 },
{ 2530 },
{ 2531 },
{ 2532 },
{ 2533 },
{ 2534 },
{ 2535 },
{ 2536 },
{ 2537 },
{ 2538 },
{ 2539 },
{ 2540 },
{ 2541 },
{ 2542 },
{ 2543 },
{ 2544 },
{ 2545 },
{ 2546 },
{ 2547 },
{ 2548 },
{ 2549 },
{ 2551 },
{ 2552 },
{ 2553 },
{ 2554 },
{ 2555 },
{ 2556 },
{ 2557 },
{ 2558 },
{ 2559 },
{ 2560 },
{ 2561 },
{ 2562 },
{ 2563 },
{ 2564 },
{ 2565 },
{ 2566 },
{ 2567 },
{ 2568 },
{ 2569 },
{ 2570 },
{ 2571 },
{ 2572 },
{ 2573 },
{ 2574 },
{ 2575 },
{ 2576 },
{ 2577 },
{ 2578 },
{ 2579 },
{ 2580 },
{ 2581 },
{ 2582 },
{ 2583 },
{ 2584 },
{ 2585 },
{ 2586 },
{ 2587 },
{ 2588 },
{ 2589 },
{ 2590 },
{ 2591 },
{ 2592 },
{ 2593 },
{ 2594 },
{ 2595 },
{ 2596 },
{ 2597 },
{ 2598 },
{ 2599 },
{ 2600 },
{ 2601 },
{ 2602 },
{ 2603 },
{ 2604 },
{ 2605 },
{ 2606 },
{ 2607 },
{ 2608 },
{ 2609 },
{ 2610 },
{ 2611 },
{ 2612 },
{ 2613 },
{ 2614 },
{ 2615 },
{ 2616 },
{ 2617 },
{ 2618 },
{ 2619 },
{ 2620 },
{ 2621 },
{ 2622 },
{ 2623 },
{ 2624 },
{ 2625 },
{ 2626 },
{ 2627 },
{ 2628 },
{ 2629 },
{ 2630 },
{ 2631 },
{ 2632 },
{ 2633 },
{ 2634 },
{ 2635 },
{ 2636 },
{ 2637 },
{ 2638 },
{ 2639 },
{ 2640 },
{ 2641 },
{ 2642 },
{ 2643 },
{ 2644 },
{ 2645 },
{ 2646 },
{ 2647 },
{ 2648 },
{ 2649 },
{ 2650 },
{ 2651 },
{ 2652 },
{ 2653 },
{ 2654 },
{ 2655 },
{ 2656 },
{ 2657 },
{ 2658 },
{ 2659 },
{ 2660 },
{ 2661 },
{ 2662 },
{ 2663 },
{ 2664 },
{ 2665 },
{ 2666 },
{ 2667 },
{ 2668 },
{ 2669 },
{ 2670 },
{ 2671 },
{ 2672 },
{ 2673 },
{ 2674 },
{ 2675 },
{ 2676 },
{ 2677 },
{ 2678 },
{ 2679 },
{ 2680 },
{ 2681 },
{ 2682 },
{ 2683 },
{ 2684 },
{ 2685 },
{ 2686 },
{ 2687 },
{ 2688 },
{ 2689 },
{ 2690 },
{ 2691 },
{ 2692 },
{ 2693 },
{ 2694 },
{ 2695 },
{ 2696 },
{ 2697 },
{ 2698 },
{ 2699 },
{ 2700 },
{ 2701 },
{ 2702 },
{ 2703 },
{ 2704 },
{ 2705 },
{ 2706 },
{ 2707 },
{ 2708 },
{ 2709 },
{ 2710 },
{ 2711 },
{ 2712 },
{ 2713 },
{ 2714 },
{ 2715 },
{ 2716 },
{ 2717 },
{ 2718 },
{ 2719 },
{ 2720 },
{ 2721 },
{ 2722 },
{ 2723 },
{ 2724 },
{ 2725 },
{ 2726 },
{ 2727 },
{ 2728 },
{ 2729 },
{ 2730 },
{ 2731 },
{ 2732 },
{ 2733 },
{ 2734 },
{ 2735 },
{ 2738 },
{ 2739 },
{ 2740 },
{ 2741 },
{ 2742 },
{ 2743 },
{ 2744 },
{ 2745 },
{ 2746 },
{ 2747 },
{ 2748 },
{ 2749 },
{ 2750 },
{ 2751 },
{ 2752 },
{ 2753 },
{ 2754 },
{ 2755 },
{ 2756 },
{ 2757 },
{ 2758 },
{ 2935 },
{ 2936 },
{ 2937 },
{ 2938 },
{ 2939 },
{ 2940 },
{ 2941 },
{ 2953 },
{ 2963 },
{ 3006 },
{ 3007 },
{ 3008 },
{ 3009 },
{ 3010 },
{ 3011 },
{ 3012 },
{ 3013 },
{ 3014 },
{ 3015 },
{ 3016 },
{ 3017 },
{ 3018 },
{ 3019 },
{ 3020 },
{ 3021 },
{ 3022 },
{ 3023 },
{ 3024 },
{ 3025 },
{ 3026 },
{ 3027 },
{ 3028 },
{ 3029 },
{ 3030 },
{ 3034 },
{ 3035 },
{ 3038 },
{ 3039 },
{ 3040 },
{ 3041 },
{ 3042 },
{ 3043 },
{ 3044 },
{ 3045 },
{ 3046 },
{ 3047 },
{ 3048 },
{ 3049 },
{ 3050 },
{ 3051 },
{ 3058 },
{ 3059 },
{ 3068 },
{ 3114 },
{ 3115 },
{ 3116 },
{ 3117 },
{ 3118 },
{ 3120 },
{ 3126 },
{ 3127 },
{ 3128 },
{ 3129 },
{ 3130 },
{ 3131 },
{ 3132 },
{ 3133 },
{ 3134 },
{ 3135 },
{ 3136 },
{ 3137 },
{ 3138 },
{ 3139 },
{ 3140 },
{ 3146 },
{ 3147 },
{ 3150 },
{ 3151 },
{ 3152 },
{ 3300 },
{ 3301 },
{ 3328 },
{ 3329 },
{ 3330 },
{ 3331 },
{ 3332 },
{ 3333 },
{ 3334 },
{ 3335 },
{ 3346 },
{ 3350 },
{ 3351 },
{ 3352 },
{ 3366 },
{ 3386 },
{ 3387 },
{ 3388 },
{ 3389 },
{ 3390 },
{ 3396 },
{ 3397 },
{ 3398 },
{ 3399 },
{ 3407 },
{ 3414 },
{ 3416 },
{ 3764 },
{ 3788 },
{ 3789 },
{ 3790 },
{ 3791 },
{ 3793 },
{ 3795 },
{ 3796 },
{ 3819 },
{ 3821 },
{ 3823 },
{ 3824 },
{ 3833 },
{ 3834 },
{ 3835 },
{ 3836 },
{ 3837 },
{ 3838 },
{ 3839 },
{ 3840 },
{ 3841 },
{ 3842 },
{ 3843 },
{ 3844 },
{ 3845 },
{ 3846 },
{ 3847 },
{ 3848 },
{ 3849 },
{ 3850 },
{ 3851 },
{ 3852 },
{ 3854 },
{ 3873 },
{ 3874 },
{ 3875 },
{ 3876 },
{ 3877 },
{ 3878 },
{ 3879 },
{ 3880 },
{ 3881 },
{ 3882 },
{ 3883 },
{ 3884 },
{ 3885 },
{ 3888 },
{ 3889 },
{ 3906 },
{ 3907 },
{ 3908 },
{ 3909 },
{ 3910 },
{ 3911 },
{ 4001 },
{ 4002 },
{ 4003 },
{ 4004 },
{ 4005 },
{ 4006 },
{ 4007 },
{ 4008 },
{ 4009 },
{ 4010 },
{ 4011 },
{ 4012 },
{ 4013 },
{ 4014 },
{ 4015 },
{ 4016 },
{ 4017 },
{ 4018 },
{ 4019 },
{ 4020 },
{ 4021 },
{ 4022 },
{ 4023 },
{ 4024 },
{ 4025 },
{ 4026 },
{ 4027 },
{ 4028 },
{ 4029 },
{ 4030 },
{ 4031 },
{ 4032 },
{ 4033 },
{ 4034 },
{ 4035 },
{ 4036 },
{ 4037 },
{ 4038 },
{ 4040 },
{ 4041 },
{ 4042 },
{ 4043 },
{ 4044 },
{ 4045 },
{ 4046 },
{ 4047 },
{ 4052 },
{ 4053 },
{ 4054 },
{ 4055 },
{ 4074 },
{ 4075 },
{ 4080 },
{ 4081 },
{ 4120 },
{ 4121 },
{ 4122 },
{ 4123 },
{ 4124 },
{ 4125 },
{ 4126 },
{ 4127 },
{ 4128 },
{ 4129 },
{ 4130 },
{ 4131 },
{ 4132 },
{ 4133 },
{ 4134 },
{ 4135 },
{ 4136 },
{ 4137 },
{ 4138 },
{ 4139 },
{ 4140 },
{ 4141 },
{ 4142 },
{ 4143 },
{ 4144 },
{ 4145 },
{ 4146 },
{ 4147 },
{ 4148 },
{ 4149 },
{ 4150 },
{ 4151 },
{ 4152 },
{ 4153 },
{ 4154 },
{ 4155 },
{ 4156 },
{ 4157 },
{ 4158 },
{ 4159 },
{ 4160 },
{ 4161 },
{ 4162 },
{ 4163 },
{ 4164 },
{ 4165 },
{ 4166 },
{ 4167 },
{ 4168 },
{ 4169 },
{ 4170 },
{ 4171 },
{ 4172 },
{ 4173 },
{ 4174 },
{ 4175 },
{ 4176 },
{ 4178 },
{ 4179 },
{ 4180 },
{ 4181 },
{ 4182 },
{ 4183 },
{ 4184 },
{ 4185 },
{ 4188 },
{ 4189 },
{ 4190 },
{ 4191 },
{ 4192 },
{ 4193 },
{ 4194 },
{ 4195 },
{ 4196 },
{ 4197 },
{ 4198 },
{ 4199 },
{ 4200 },
{ 4201 },
{ 4202 },
{ 4203 },
{ 4204 },
{ 4205 },
{ 4206 },
{ 4207 },
{ 4208 },
{ 4209 },
{ 4210 },
{ 4211 },
{ 4212 },
{ 4213 },
{ 4214 },
{ 4215 },
{ 4216 },
{ 4218 },
{ 4219 },
{ 4220 },
{ 4221 },
{ 4222 },
{ 4223 },
{ 4224 },
{ 4225 },
{ 4226 },
{ 4227 },
{ 4228 },
{ 4229 },
{ 4230 },
{ 4231 },
{ 4232 },
{ 4233 },
{ 4234 },
{ 4235 },
{ 4236 },
{ 4237 },
{ 4238 },
{ 4239 },
{ 4240 },
{ 4241 },
{ 4242 },
{ 4243 },
{ 4244 },
{ 4245 },
{ 4246 },
{ 4247 },
{ 4248 },
{ 4249 },
{ 4250 },
{ 4251 },
{ 4252 },
{ 4253 },
{ 4254 },
{ 4255 },
{ 4256 },
{ 4257 },
{ 4259 },
{ 4260 },
{ 4261 },
{ 4262 },
{ 4263 },
{ 4264 },
{ 4265 },
{ 4266 },
{ 4267 },
{ 4268 },
{ 4269 },
{ 4270 },
{ 4271 },
{ 4272 },
{ 4273 },
{ 4274 },
{ 4275 },
{ 4276 },
{ 4277 },
{ 4278 },
{ 4279 },
{ 4280 },
{ 4281 },
{ 4282 },
{ 4283 },
{ 4284 },
{ 4285 },
{ 4286 },
{ 4287 },
{ 4288 },
{ 4289 },
{ 4291 },
{ 4292 },
{ 4293 },
{ 4294 },
{ 4295 },
{ 4296 },
{ 4297 },
{ 4298 },
{ 4299 },
{ 4300 },
{ 4301 },
{ 4302 },
{ 4303 },
{ 4304 },
{ 4306 },
{ 4307 },
{ 4308 },
{ 4309 },
{ 4310 },
{ 4311 },
{ 4312 },
{ 4313 },
{ 4314 },
{ 4315 },
{ 4316 },
{ 4317 },
{ 4318 },
{ 4319 },
{ 4322 },
{ 4324 },
{ 4327 },
{ 4329 },
{ 4339 },
{ 4341 },
{ 4343 },
{ 4345 },
{ 4347 },
{ 4349 },
{ 4351 },
{ 4353 },
{ 4355 },
{ 4357 },
{ 4359 },
{ 4361 },
{ 4363 },
{ 4365 },
{ 4367 },
{ 4369 },
{ 4371 },
{ 4373 },
{ 4375 },
{ 4377 },
{ 4379 },
{ 4381 },
{ 4383 },
{ 4386 },
{ 4388 },
{ 4417 },
{ 4434 },
{ 4463 },
{ 4466 },
{ 4469 },
{ 4470 },
{ 4472 },
{ 4475 },
{ 4480 },
{ 4482 },
{ 4483 },
{ 4490 },
{ 4491 },
{ 4492 },
{ 4493 },
{ 4494 },
{ 4495 },
{ 4496 },
{ 4497 },
{ 4498 },
{ 4499 },
{ 4500 },
{ 4501 },
{ 4502 },
{ 4503 },
{ 4504 },
{ 4505 },
{ 4506 },
{ 4507 },
{ 4508 },
{ 4509 },
{ 4510 },
{ 4511 },
{ 4512 },
{ 4513 },
{ 4514 },
{ 4515 },
{ 4516 },
{ 4517 },
{ 4518 },
{ 4519 },
{ 4520 },
{ 4521 },
{ 4522 },
{ 4523 },
{ 4524 },
{ 4525 },
{ 4526 },
{ 4527 },
{ 4528 },
{ 4529 },
{ 4530 },
{ 4531 },
{ 4532 },
{ 4533 },
{ 4534 },
{ 4535 },
{ 4536 },
{ 4537 },
{ 4538 },
{ 4539 },
{ 4540 },
{ 4541 },
{ 4542 },
{ 4543 },
{ 4544 },
{ 4545 },
{ 4546 },
{ 4547 },
{ 4548 },
{ 4549 },
{ 4550 },
{ 4551 },
{ 4552 },
{ 4553 },
{ 4554 },
{ 4555 },
{ 4557 },
{ 4558 },
{ 4568 },
{ 4569 },
{ 4570 },
{ 4571 },
{ 4572 },
{ 4573 },
{ 4574 },
{ 4575 },
{ 4576 },
{ 4577 },
{ 4578 },
{ 4579 },
{ 4580 },
{ 4581 },
{ 4582 },
{ 4583 },
{ 4584 },
{ 4585 },
{ 4586 },
{ 4587 },
{ 4588 },
{ 4589 },
{ 4600 },
{ 4601 },
{ 4602 },
{ 4603 },
{ 4604 },
{ 4605 },
{ 4606 },
{ 4607 },
{ 4608 },
{ 4609 },
{ 4610 },
{ 4611 },
{ 4612 },
{ 4613 },
{ 4614 },
{ 4615 },
{ 4616 },
{ 4617 },
{ 4618 },
{ 4619 },
{ 4620 },
{ 4621 },
{ 4622 },
{ 4623 },
{ 4624 },
{ 4625 },
{ 4626 },
{ 4627 },
{ 4628 },
{ 4629 },
{ 4630 },
{ 4631 },
{ 4632 },
{ 4633 },
{ 4634 },
{ 4635 },
{ 4636 },
{ 4637 },
{ 4638 },
{ 4639 },
{ 4640 },
{ 4641 },
{ 4642 },
{ 4643 },
{ 4644 },
{ 4645 },
{ 4646 },
{ 4652 },
{ 4653 },
{ 4654 },
{ 4655 },
{ 4656 },
{ 4657 },
{ 4658 },
{ 4659 },
{ 4660 },
{ 4661 },
{ 4662 },
{ 4663 },
{ 4664 },
{ 4665 },
{ 4666 },
{ 4667 },
{ 4668 },
{ 4669 },
{ 4670 },
{ 4671 },
{ 4672 },
{ 4673 },
{ 4674 },
{ 4675 },
{ 4676 },
{ 4677 },
{ 4678 },
{ 4679 },
{ 4680 },
{ 4681 },
{ 4682 },
{ 4683 },
{ 4684 },
{ 4685 },
{ 4686 },
{ 4687 },
{ 4688 },
{ 4689 },
{ 4690 },
{ 4691 },
{ 4692 },
{ 4693 },
{ 4694 },
{ 4695 },
{ 4696 },
{ 4697 },
{ 4698 },
{ 4699 },
{ 4700 },
{ 4701 },
{ 4702 },
{ 4703 },
{ 4704 },
{ 4705 },
{ 4706 },
{ 4707 },
{ 4708 },
{ 4709 },
{ 4710 },
{ 4711 },
{ 4712 },
{ 4713 },
{ 4714 },
{ 4715 },
{ 4716 },
{ 4717 },
{ 4718 },
{ 4719 },
{ 4720 },
{ 4721 },
{ 4722 },
{ 4723 },
{ 4724 },
{ 4725 },
{ 4726 },
{ 4727 },
{ 4728 },
{ 4729 },
{ 4730 },
{ 4731 },
{ 4732 },
{ 4733 },
{ 4734 },
{ 4735 },
{ 4736 },
{ 4737 },
{ 4738 },
{ 4739 },
{ 4740 },
{ 4741 },
{ 4742 },
{ 4743 },
{ 4744 },
{ 4745 },
{ 4746 },
{ 4747 },
{ 4748 },
{ 4749 },
{ 4750 },
{ 4751 },
{ 4752 },
{ 4753 },
{ 4754 },
{ 4755 },
{ 4756 },
{ 4757 },
{ 4758 },
{ 4759 },
{ 4760 },
{ 4761 },
{ 4762 },
{ 4763 },
{ 4764 },
{ 4765 },
{ 4766 },
{ 4767 },
{ 4768 },
{ 4769 },
{ 4770 },
{ 4771 },
{ 4772 },
{ 4773 },
{ 4774 },
{ 4775 },
{ 4776 },
{ 4777 },
{ 4778 },
{ 4779 },
{ 4780 },
{ 4781 },
{ 4782 },
{ 4783 },
{ 4784 },
{ 4785 },
{ 4786 },
{ 4787 },
{ 4788 },
{ 4789 },
{ 4790 },
{ 4791 },
{ 4792 },
{ 4793 },
{ 4794 },
{ 4795 },
{ 4796 },
{ 4797 },
{ 4798 },
{ 4799 },
{ 4800 },
{ 4801 },
{ 4802 },
{ 4803 },
{ 4804 },
{ 4805 },
{ 4806 },
{ 4807 },
{ 4808 },
{ 4809 },
{ 4810 },
{ 4811 },
{ 4812 },
{ 4813 },
{ 4814 },
{ 4815 },
{ 4816 },
{ 4817 },
{ 4818 },
{ 4819 },
{ 4820 },
{ 4821 },
{ 4822 },
{ 4823 },
{ 4824 },
{ 4839 },
{ 4855 },
{ 4856 },
{ 4857 },
{ 4858 },
{ 4859 },
{ 4860 },
{ 4861 },
{ 4862 },
{ 4863 },
{ 4864 },
{ 4865 },
{ 4866 },
{ 4867 },
{ 4868 },
{ 4869 },
{ 4870 },
{ 4871 },
{ 4872 },
{ 4873 },
{ 4874 },
{ 4875 },
{ 4876 },
{ 4877 },
{ 4878 },
{ 4879 },
{ 4880 },
{ 4883 },
{ 4885 },
{ 4887 },
{ 4889 },
{ 4891 },
{ 4893 },
{ 4895 },
{ 4898 },
{ 4900 },
{ 4901 },
{ 4902 },
{ 4903 },
{ 4904 },
{ 4907 },
{ 4909 },
{ 4921 },
{ 4923 },
{ 4925 },
{ 4927 },
{ 4929 },
{ 4931 },
{ 4933 },
{ 4935 },
{ 4937 },
{ 4939 },
{ 4941 },
{ 4943 },
{ 4945 },
{ 4947 },
{ 4949 },
{ 4951 },
{ 4953 },
{ 4955 },
{ 4957 },
{ 4959 },
{ 4961 },
{ 4963 },
{ 4965 },
{ 4967 },
{ 4969 },
{ 4971 },
{ 4973 },
{ 4975 },
{ 4977 },
{ 4979 },
{ 4981 },
{ 4983 },
{ 4985 },
{ 4987 },
{ 4989 },
{ 4991 },
{ 4993 },
{ 4995 },
{ 4997 },
{ 4999 },
{ 5012 },
{ 5013 },
{ 5017 },
{ 5048 },
{ 5105 },
{ 5106 },
{ 5107 },
{ 5108 },
{ 5109 },
{ 5110 },
{ 5111 },
{ 5112 },
{ 5113 },
{ 5114 },
{ 5115 },
{ 5116 },
{ 5117 },
{ 5118 },
{ 5119 },
{ 5120 },
{ 5121 },
{ 5122 },
{ 5123 },
{ 5124 },
{ 5125 },
{ 5126 },
{ 5127 },
{ 5128 },
{ 5129 },
{ 5130 },
{ 5132 },
{ 5167 },
{ 5168 },
{ 5169 },
{ 5170 },
{ 5171 },
{ 5172 },
{ 5173 },
{ 5174 },
{ 5175 },
{ 5176 },
{ 5177 },
{ 5178 },
{ 5179 },
{ 5180 },
{ 5181 },
{ 5182 },
{ 5183 },
{ 5184 },
{ 5185 },
{ 5186 },
{ 5187 },
{ 5188 },
{ 5224 },
{ 5228 },
{ 5229 },
{ 5233 },
{ 5245 },
{ 5246 },
{ 5251 },
{ 5252 },
{ 5253 },
{ 5254 },
{ 5255 },
{ 5256 },
{ 5257 },
{ 5258 },
{ 5259 },
{ 5263 },
{ 5264 },
{ 5269 },
{ 5270 },
{ 5271 },
{ 5272 },
{ 5273 },
{ 5274 },
{ 5275 },
{ 5801 },
{ 5802 },
{ 5803 },
{ 5804 },
{ 5808 },
{ 5809 },
{ 5810 },
{ 5811 },
{ 5812 },
{ 5813 },
{ 5814 },
{ 5815 },
{ 5816 },
{ 20004 },
{ 20005 },
{ 20006 },
{ 20007 },
{ 20008 },
{ 20009 },
{ 20010 },
{ 20011 },
{ 20012 },
{ 20013 },
{ 20014 },
{ 20015 },
{ 20016 },
{ 20017 },
{ 20018 },
{ 20019 },
{ 20020 },
{ 20021 },
{ 20022 },
{ 20023 },
{ 20024 },
{ 20025 },
{ 20026 },
{ 20027 },
{ 20028 },
{ 20029 },
{ 20030 },
{ 20031 },
{ 20032 },
{ 20064 },
{ 20065 },
{ 20066 },
{ 20067 },
{ 20068 },
{ 20069 },
{ 20070 },
{ 20071 },
{ 20072 },
{ 20073 },
{ 20074 },
{ 20075 },
{ 20076 },
{ 20077 },
{ 20078 },
{ 20079 },
{ 20080 },
{ 20081 },
{ 20082 },
{ 20083 },
{ 20084 },
{ 20085 },
{ 20086 },
{ 20087 },
{ 20088 },
{ 20089 },
{ 20090 },
{ 20091 },
{ 20092 },
{ 21413 },
{ 21414 },
{ 21415 },
{ 21416 },
{ 21417 },
{ 21418 },
{ 21419 },
{ 21420 },
{ 21421 },
{ 21422 },
{ 21423 },
{ 21453 },
{ 21454 },
{ 21455 },
{ 21456 },
{ 21457 },
{ 21458 },
{ 21459 },
{ 21460 },
{ 21461 },
{ 21462 },
{ 21463 },
{ 21473 },
{ 21474 },
{ 21475 },
{ 21476 },
{ 21477 },
{ 21478 },
{ 21479 },
{ 21480 },
{ 21481 },
{ 21482 },
{ 21483 },
{ 21896 },
{ 21897 },
{ 21898 },
{ 21899 },
{ 22171 },
{ 22172 },
{ 22173 },
{ 22174 },
{ 22175 },
{ 22176 },
{ 22177 },
{ 22181 },
{ 22182 },
{ 22183 },
{ 22184 },
{ 22185 },
{ 22186 },
{ 22187 },
{ 22191 },
{ 22192 },
{ 22193 },
{ 22194 },
{ 22195 },
{ 22196 },
{ 22197 },
{ 25884 },
{ 27205 },
{ 27206 },
{ 27207 },
{ 27208 },
{ 27209 },
{ 27210 },
{ 27211 },
{ 27212 },
{ 27213 },
{ 27214 },
{ 27215 },
{ 27216 },
{ 27217 },
{ 27218 },
{ 27219 },
{ 27220 },
{ 27221 },
{ 27222 },
{ 27223 },
{ 27224 },
{ 27225 },
{ 27226 },
{ 27227 },
{ 27228 },
{ 27229 },
{ 27230 },
{ 27231 },
{ 27232 },
{ 27391 },
{ 27392 },
{ 27393 },
{ 27394 },
{ 27395 },
{ 27396 },
{ 27397 },
{ 27398 },
{ 27492 },
{ 28402 },
{ 28403 },
{ 28404 },
{ 28405 },
{ 28406 },
{ 28407 },
{ 28408 },
{ 28409 },
{ 28410 },
{ 28411 },
{ 28412 },
{ 28413 },
{ 28414 },
{ 28415 },
{ 28416 },
{ 28417 },
{ 28418 },
{ 28419 },
{ 28420 },
{ 28421 },
{ 28422 },
{ 28423 },
{ 28424 },
{ 28425 },
{ 28426 },
{ 28427 },
{ 28428 },
{ 28429 },
{ 28430 },
{ 28431 },
{ 28432 },
{ 28462 },
{ 28463 },
{ 28464 },
{ 28465 },
{ 28466 },
{ 28467 },
{ 28468 },
{ 28469 },
{ 28470 },
{ 28471 },
{ 28472 },
{ 28473 },
{ 28474 },
{ 28475 },
{ 28476 },
{ 28477 },
{ 28478 },
{ 28479 },
{ 28480 },
{ 28481 },
{ 28482 },
{ 28483 },
{ 28484 },
{ 28485 },
{ 28486 },
{ 28487 },
{ 28488 },
{ 28489 },
{ 28490 },
{ 28491 },
{ 28492 },
{ 29701 },
{ 29702 },
{ 30161 },
{ 30162 },
{ 30163 },
{ 30164 },
{ 30165 },
{ 30166 },
{ 30167 },
{ 30168 },
{ 30169 },
{ 30170 },
{ 30171 },
{ 30172 },
{ 30173 },
{ 30174 },
{ 30175 },
{ 30176 },
{ 30177 },
{ 30178 },
{ 30179 },
{ 30800 },
{ 31251 },
{ 31252 },
{ 31253 },
{ 31254 },
{ 31255 },
{ 31256 },
{ 31257 },
{ 31258 },
{ 31259 },
{ 31275 },
{ 31276 },
{ 31277 },
{ 31278 },
{ 31279 },
{ 31281 },
{ 31282 },
{ 31283 },
{ 31284 },
{ 31285 },
{ 31286 },
{ 31287 },
{ 31288 },
{ 31289 },
{ 31290 },
{ 31700 },
};
#define AXIS_ORIENTATION_TABLE_SIZE 1703
int mapcache_is_axis_inverted(const char *srs)
{
int i,code;
if(strncasecmp(srs,"epsg:",5) || strlen(srs)<6) {
/* if we don't have an epsg formated srs */
return MAPCACHE_FALSE;
}
code = atoi(&(srs[5]));
/*check the static table*/
for (i=0; i
#define INITIAL_BUFFER_SIZE 100
static void _mapcache_buffer_realloc(mapcache_buffer *buffer, apr_off_t len)
{
if(buffer->avail) {
unsigned char* newbuf ;
while ( len > buffer->avail ) {
buffer->avail += buffer->avail;
}
newbuf = realloc(buffer->buf, buffer->avail) ;
if ( newbuf != buffer->buf ) {
if ( buffer->buf )
apr_pool_cleanup_kill(buffer->pool, buffer->buf, (void*)free) ;
apr_pool_cleanup_register(buffer->pool, newbuf,(void*)free, apr_pool_cleanup_null);
buffer->buf = newbuf ;
}
} else {
buffer->avail = len;
buffer->buf = malloc(buffer->avail);
apr_pool_cleanup_register(buffer->pool, buffer->buf,(void*)free, apr_pool_cleanup_null);
}
}
mapcache_buffer *mapcache_buffer_create(size_t initialStorage, apr_pool_t* pool)
{
mapcache_buffer *buffer = apr_pcalloc(pool, sizeof(mapcache_buffer));
if(!buffer) return NULL;
buffer->pool = pool;
buffer->avail = initialStorage;
if(buffer->avail) {
buffer->buf = malloc(buffer->avail);
apr_pool_cleanup_register(buffer->pool, buffer->buf,(void*)free, apr_pool_cleanup_null);
} else {
buffer->buf = NULL;
}
return buffer;
}
int mapcache_buffer_append(mapcache_buffer *buffer, size_t len, void *data)
{
size_t total = buffer->size + len;
if(total > buffer->avail)
_mapcache_buffer_realloc(buffer,total);
memcpy(((unsigned char*)buffer->buf) + buffer->size, data, len);
buffer->size += len;
return len;
}
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cJSON.c 0000664 0000000 0000000 00000216621 14653160677 0015772 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* cJSON */
/* JSON parser in C. */
/* disable warnings about old C89 functions in MSVC */
#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
#define _CRT_SECURE_NO_DEPRECATE
#endif
#ifdef __GNUC__
#pragma GCC visibility push(default)
#endif
#if defined(_MSC_VER)
#pragma warning (push)
/* disable warning about single line comments in system headers */
#pragma warning (disable : 4001)
#endif
#include
#include
#include
#include
#include
#include
#include
#ifdef ENABLE_LOCALES
#include
#endif
#if defined(_MSC_VER)
#pragma warning (pop)
#endif
#ifdef __GNUC__
#pragma GCC visibility pop
#endif
#include "cJSON.h"
/* define our own boolean type */
#define true ((cJSON_bool)1)
#define false ((cJSON_bool)0)
typedef struct {
const unsigned char *json;
size_t position;
} error;
static error global_error = { NULL, 0 };
CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
{
return (const char*) (global_error.json + global_error.position);
}
CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item) {
if (!cJSON_IsString(item)) {
return NULL;
}
return item->valuestring;
}
/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 3)
#error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
#endif
CJSON_PUBLIC(const char*) cJSON_Version(void)
{
static char version[15];
sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
return version;
}
/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
{
if ((string1 == NULL) || (string2 == NULL))
{
return 1;
}
if (string1 == string2)
{
return 0;
}
for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
{
if (*string1 == '\0')
{
return 0;
}
}
return tolower(*string1) - tolower(*string2);
}
typedef struct internal_hooks
{
void *(*allocate)(size_t size);
void (*deallocate)(void *pointer);
void *(*reallocate)(void *pointer, size_t size);
} internal_hooks;
#if defined(_MSC_VER)
/* work around MSVC error C2322: '...' address of dillimport '...' is not static */
static void *internal_malloc(size_t size)
{
return malloc(size);
}
static void internal_free(void *pointer)
{
free(pointer);
}
static void *internal_realloc(void *pointer, size_t size)
{
return realloc(pointer, size);
}
#else
#define internal_malloc malloc
#define internal_free free
#define internal_realloc realloc
#endif
static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
{
size_t length = 0;
unsigned char *copy = NULL;
if (string == NULL)
{
return NULL;
}
length = strlen((const char*)string) + sizeof("");
copy = (unsigned char*)hooks->allocate(length);
if (copy == NULL)
{
return NULL;
}
memcpy(copy, string, length);
return copy;
}
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
{
if (hooks == NULL)
{
/* Reset hooks */
global_hooks.allocate = malloc;
global_hooks.deallocate = free;
global_hooks.reallocate = realloc;
return;
}
global_hooks.allocate = malloc;
if (hooks->malloc_fn != NULL)
{
global_hooks.allocate = hooks->malloc_fn;
}
global_hooks.deallocate = free;
if (hooks->free_fn != NULL)
{
global_hooks.deallocate = hooks->free_fn;
}
/* use realloc only if both free and malloc are used */
global_hooks.reallocate = NULL;
if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
{
global_hooks.reallocate = realloc;
}
}
/* Internal constructor. */
static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
{
cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
if (node)
{
memset(node, '\0', sizeof(cJSON));
}
return node;
}
/* Delete a cJSON structure. */
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
{
cJSON *next = NULL;
while (item != NULL)
{
next = item->next;
if (!(item->type & cJSON_IsReference) && (item->child != NULL))
{
cJSON_Delete(item->child);
}
if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
{
global_hooks.deallocate(item->valuestring);
}
if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
{
global_hooks.deallocate(item->string);
}
global_hooks.deallocate(item);
item = next;
}
}
/* get the decimal point character of the current locale */
static unsigned char get_decimal_point(void)
{
#ifdef ENABLE_LOCALES
struct lconv *lconv = localeconv();
return (unsigned char) lconv->decimal_point[0];
#else
return '.';
#endif
}
typedef struct
{
const unsigned char *content;
size_t length;
size_t offset;
size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
internal_hooks hooks;
} parse_buffer;
/* check if the given size is left to read in a given parse buffer (starting with 1) */
#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
/* check if the buffer can be accessed at the given index (starting with 0) */
#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
/* get a pointer to the buffer at the position */
#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
/* Parse the input text to generate a number, and populate the result into item. */
static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
{
double number = 0;
unsigned char *after_end = NULL;
unsigned char number_c_string[64];
unsigned char decimal_point = get_decimal_point();
size_t i = 0;
if ((input_buffer == NULL) || (input_buffer->content == NULL))
{
return false;
}
/* copy the number into a temporary buffer and replace '.' with the decimal point
* of the current locale (for strtod)
* This also takes care of '\0' not necessarily being available for marking the end of the input */
for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
{
switch (buffer_at_offset(input_buffer)[i])
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '+':
case '-':
case 'e':
case 'E':
number_c_string[i] = buffer_at_offset(input_buffer)[i];
break;
case '.':
number_c_string[i] = decimal_point;
break;
default:
goto loop_end;
}
}
loop_end:
number_c_string[i] = '\0';
number = strtod((const char*)number_c_string, (char**)&after_end);
if (number_c_string == after_end)
{
return false; /* parse_error */
}
item->valuedouble = number;
/* use saturation in case of overflow */
if (number >= INT_MAX)
{
item->valueint = INT_MAX;
}
else if (number <= INT_MIN)
{
item->valueint = INT_MIN;
}
else
{
item->valueint = (int)number;
}
item->type = cJSON_Number;
input_buffer->offset += (size_t)(after_end - number_c_string);
return true;
}
/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
{
if (number >= INT_MAX)
{
object->valueint = INT_MAX;
}
else if (number <= INT_MIN)
{
object->valueint = INT_MIN;
}
else
{
object->valueint = (int)number;
}
return object->valuedouble = number;
}
typedef struct
{
unsigned char *buffer;
size_t length;
size_t offset;
size_t depth; /* current nesting depth (for formatted printing) */
cJSON_bool noalloc;
cJSON_bool format; /* is this print a formatted print */
internal_hooks hooks;
} printbuffer;
/* realloc printbuffer if necessary to have at least "needed" bytes more */
static unsigned char* ensure(printbuffer * const p, size_t needed)
{
unsigned char *newbuffer = NULL;
size_t newsize = 0;
if ((p == NULL) || (p->buffer == NULL))
{
return NULL;
}
if ((p->length > 0) && (p->offset >= p->length))
{
/* make sure that offset is valid */
return NULL;
}
if (needed > INT_MAX)
{
/* sizes bigger than INT_MAX are currently not supported */
return NULL;
}
needed += p->offset + 1;
if (needed <= p->length)
{
return p->buffer + p->offset;
}
if (p->noalloc) {
return NULL;
}
/* calculate new buffer size */
if (needed > (INT_MAX / 2))
{
/* overflow of int, use INT_MAX if possible */
if (needed <= INT_MAX)
{
newsize = INT_MAX;
}
else
{
return NULL;
}
}
else
{
newsize = needed * 2;
}
if (p->hooks.reallocate != NULL)
{
/* reallocate with realloc if available */
newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
if (newbuffer == NULL)
{
p->hooks.deallocate(p->buffer);
p->length = 0;
p->buffer = NULL;
return NULL;
}
}
else
{
/* otherwise reallocate manually */
newbuffer = (unsigned char*)p->hooks.allocate(newsize);
if (!newbuffer)
{
p->hooks.deallocate(p->buffer);
p->length = 0;
p->buffer = NULL;
return NULL;
}
if (newbuffer)
{
memcpy(newbuffer, p->buffer, p->offset + 1);
}
p->hooks.deallocate(p->buffer);
}
p->length = newsize;
p->buffer = newbuffer;
return newbuffer + p->offset;
}
/* calculate the new length of the string in a printbuffer and update the offset */
static void update_offset(printbuffer * const buffer)
{
const unsigned char *buffer_pointer = NULL;
if ((buffer == NULL) || (buffer->buffer == NULL))
{
return;
}
buffer_pointer = buffer->buffer + buffer->offset;
buffer->offset += strlen((const char*)buffer_pointer);
}
/* Render the number nicely from the given item into a string. */
static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output_pointer = NULL;
double d = item->valuedouble;
int length = 0;
size_t i = 0;
unsigned char number_buffer[26]; /* temporary buffer to print the number into */
unsigned char decimal_point = get_decimal_point();
double test;
if (output_buffer == NULL)
{
return false;
}
/* This checks for NaN and Infinity */
if ((d * 0) != 0)
{
length = sprintf((char*)number_buffer, "null");
}
else
{
/* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
length = sprintf((char*)number_buffer, "%1.15g", d);
/* Check whether the original double can be recovered */
if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || ((double)test != d))
{
/* If not, print with 17 decimal places of precision */
length = sprintf((char*)number_buffer, "%1.17g", d);
}
}
/* sprintf failed or buffer overrun occured */
if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
{
return false;
}
/* reserve appropriate space in the output */
output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
if (output_pointer == NULL)
{
return false;
}
/* copy the printed number to the output and replace locale
* dependent decimal point with '.' */
for (i = 0; i < ((size_t)length); i++)
{
if (number_buffer[i] == decimal_point)
{
output_pointer[i] = '.';
continue;
}
output_pointer[i] = number_buffer[i];
}
output_pointer[i] = '\0';
output_buffer->offset += (size_t)length;
return true;
}
/* parse 4 digit hexadecimal number */
static unsigned parse_hex4(const unsigned char * const input)
{
unsigned int h = 0;
size_t i = 0;
for (i = 0; i < 4; i++)
{
/* parse digit */
if ((input[i] >= '0') && (input[i] <= '9'))
{
h += (unsigned int) input[i] - '0';
}
else if ((input[i] >= 'A') && (input[i] <= 'F'))
{
h += (unsigned int) 10 + input[i] - 'A';
}
else if ((input[i] >= 'a') && (input[i] <= 'f'))
{
h += (unsigned int) 10 + input[i] - 'a';
}
else /* invalid */
{
return 0;
}
if (i < 3)
{
/* shift left to make place for the next nibble */
h = h << 4;
}
}
return h;
}
/* converts a UTF-16 literal to UTF-8
* A literal can be one or two sequences of the form \uXXXX */
static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
{
long unsigned int codepoint = 0;
unsigned int first_code = 0;
const unsigned char *first_sequence = input_pointer;
unsigned char utf8_length = 0;
unsigned char utf8_position = 0;
unsigned char sequence_length = 0;
unsigned char first_byte_mark = 0;
if ((input_end - first_sequence) < 6)
{
/* input ends unexpectedly */
goto fail;
}
/* get the first utf16 sequence */
first_code = parse_hex4(first_sequence + 2);
/* check that the code is valid */
if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
{
goto fail;
}
/* UTF16 surrogate pair */
if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
{
const unsigned char *second_sequence = first_sequence + 6;
unsigned int second_code = 0;
sequence_length = 12; /* \uXXXX\uXXXX */
if ((input_end - second_sequence) < 6)
{
/* input ends unexpectedly */
goto fail;
}
if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
{
/* missing second half of the surrogate pair */
goto fail;
}
/* get the second utf16 sequence */
second_code = parse_hex4(second_sequence + 2);
/* check that the code is valid */
if ((second_code < 0xDC00) || (second_code > 0xDFFF))
{
/* invalid second half of the surrogate pair */
goto fail;
}
/* calculate the unicode codepoint from the surrogate pair */
codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
}
else
{
sequence_length = 6; /* \uXXXX */
codepoint = first_code;
}
/* encode as UTF-8
* takes at maximum 4 bytes to encode:
* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
if (codepoint < 0x80)
{
/* normal ascii, encoding 0xxxxxxx */
utf8_length = 1;
}
else if (codepoint < 0x800)
{
/* two bytes, encoding 110xxxxx 10xxxxxx */
utf8_length = 2;
first_byte_mark = 0xC0; /* 11000000 */
}
else if (codepoint < 0x10000)
{
/* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
utf8_length = 3;
first_byte_mark = 0xE0; /* 11100000 */
}
else if (codepoint <= 0x10FFFF)
{
/* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
utf8_length = 4;
first_byte_mark = 0xF0; /* 11110000 */
}
else
{
/* invalid unicode codepoint */
goto fail;
}
/* encode as utf8 */
for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
{
/* 10xxxxxx */
(*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
codepoint >>= 6;
}
/* encode first byte */
if (utf8_length > 1)
{
(*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
}
else
{
(*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
}
*output_pointer += utf8_length;
return sequence_length;
fail:
return 0;
}
/* Parse the input text into an unescaped cinput, and populate item. */
static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
{
const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
unsigned char *output_pointer = NULL;
unsigned char *output = NULL;
/* not a string */
if (buffer_at_offset(input_buffer)[0] != '\"')
{
goto fail;
}
{
/* calculate approximate size of the output (overestimate) */
size_t allocation_length = 0;
size_t skipped_bytes = 0;
while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
{
/* is escape sequence */
if (input_end[0] == '\\')
{
if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
{
/* prevent buffer overflow when last input character is a backslash */
goto fail;
}
skipped_bytes++;
input_end++;
}
input_end++;
}
if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
{
goto fail; /* string ended unexpectedly */
}
/* This is at most how much we need for the output */
allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
if (output == NULL)
{
goto fail; /* allocation failure */
}
}
output_pointer = output;
/* loop through the string literal */
while (input_pointer < input_end)
{
if (*input_pointer != '\\')
{
*output_pointer++ = *input_pointer++;
}
/* escape sequence */
else
{
unsigned char sequence_length = 2;
if ((input_end - input_pointer) < 1)
{
goto fail;
}
switch (input_pointer[1])
{
case 'b':
*output_pointer++ = '\b';
break;
case 'f':
*output_pointer++ = '\f';
break;
case 'n':
*output_pointer++ = '\n';
break;
case 'r':
*output_pointer++ = '\r';
break;
case 't':
*output_pointer++ = '\t';
break;
case '\"':
case '\\':
case '/':
*output_pointer++ = input_pointer[1];
break;
/* UTF-16 literal */
case 'u':
sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
if (sequence_length == 0)
{
/* failed to convert UTF16-literal to UTF-8 */
goto fail;
}
break;
default:
goto fail;
}
input_pointer += sequence_length;
}
}
/* zero terminate the output */
*output_pointer = '\0';
item->type = cJSON_String;
item->valuestring = (char*)output;
input_buffer->offset = (size_t) (input_end - input_buffer->content);
input_buffer->offset++;
return true;
fail:
if (output != NULL)
{
input_buffer->hooks.deallocate(output);
}
if (input_pointer != NULL)
{
input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
}
return false;
}
/* Render the cstring provided to an escaped version that can be printed. */
static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
{
const unsigned char *input_pointer = NULL;
unsigned char *output = NULL;
unsigned char *output_pointer = NULL;
size_t output_length = 0;
/* numbers of additional characters needed for escaping */
size_t escape_characters = 0;
if (output_buffer == NULL)
{
return false;
}
/* empty string */
if (input == NULL)
{
output = ensure(output_buffer, sizeof("\"\""));
if (output == NULL)
{
return false;
}
strcpy((char*)output, "\"\"");
return true;
}
/* set "flag" to 1 if something needs to be escaped */
for (input_pointer = input; *input_pointer; input_pointer++)
{
switch (*input_pointer)
{
case '\"':
case '\\':
case '\b':
case '\f':
case '\n':
case '\r':
case '\t':
/* one character escape sequence */
escape_characters++;
break;
default:
if (*input_pointer < 32)
{
/* UTF-16 escape sequence uXXXX */
escape_characters += 5;
}
break;
}
}
output_length = (size_t)(input_pointer - input) + escape_characters;
output = ensure(output_buffer, output_length + sizeof("\"\""));
if (output == NULL)
{
return false;
}
/* no characters have to be escaped */
if (escape_characters == 0)
{
output[0] = '\"';
memcpy(output + 1, input, output_length);
output[output_length + 1] = '\"';
output[output_length + 2] = '\0';
return true;
}
output[0] = '\"';
output_pointer = output + 1;
/* copy the string */
for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
{
if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
{
/* normal character, copy */
*output_pointer = *input_pointer;
}
else
{
/* character needs to be escaped */
*output_pointer++ = '\\';
switch (*input_pointer)
{
case '\\':
*output_pointer = '\\';
break;
case '\"':
*output_pointer = '\"';
break;
case '\b':
*output_pointer = 'b';
break;
case '\f':
*output_pointer = 'f';
break;
case '\n':
*output_pointer = 'n';
break;
case '\r':
*output_pointer = 'r';
break;
case '\t':
*output_pointer = 't';
break;
default:
/* escape and print as unicode codepoint */
sprintf((char*)output_pointer, "u%04x", *input_pointer);
output_pointer += 4;
break;
}
}
}
output[output_length + 1] = '\"';
output[output_length + 2] = '\0';
return true;
}
/* Invoke print_string_ptr (which is useful) on an item. */
static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)
{
return print_string_ptr((unsigned char*)item->valuestring, p);
}
/* Predeclare these prototypes. */
static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);
static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);
static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);
static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);
static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);
static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);
/* Utility to jump whitespace and cr/lf */
static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->length)
{
buffer->offset--;
}
return buffer;
}
/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
{
return NULL;
}
if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
{
buffer->offset += 3;
}
return buffer;
}
/* Parse an object - create a new root, and populate. */
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
{
parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
cJSON *item = NULL;
/* reset error position */
global_error.json = NULL;
global_error.position = 0;
if (value == NULL)
{
goto fail;
}
buffer.content = (const unsigned char*)value;
buffer.length = strlen((const char*)value) + sizeof("");
buffer.offset = 0;
buffer.hooks = global_hooks;
item = cJSON_New_Item(&global_hooks);
if (item == NULL) /* memory fail */
{
goto fail;
}
if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
{
/* parse failure. ep is set. */
goto fail;
}
/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
if (require_null_terminated)
{
buffer_skip_whitespace(&buffer);
if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
{
goto fail;
}
}
if (return_parse_end)
{
*return_parse_end = (const char*)buffer_at_offset(&buffer);
}
return item;
fail:
if (item != NULL)
{
cJSON_Delete(item);
}
if (value != NULL)
{
error local_error;
local_error.json = (const unsigned char*)value;
local_error.position = 0;
if (buffer.offset < buffer.length)
{
local_error.position = buffer.offset;
}
else if (buffer.length > 0)
{
local_error.position = buffer.length - 1;
}
if (return_parse_end != NULL)
{
*return_parse_end = (const char*)local_error.json + local_error.position;
}
global_error = local_error;
}
return NULL;
}
/* Default options for cJSON_Parse */
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
{
return cJSON_ParseWithOpts(value, 0, 0);
}
#define cjson_min(a, b) ((a < b) ? a : b)
static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
{
static const size_t default_buffer_size = 256;
printbuffer buffer[1];
unsigned char *printed = NULL;
memset(buffer, 0, sizeof(buffer));
/* create buffer */
buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
buffer->length = default_buffer_size;
buffer->format = format;
buffer->hooks = *hooks;
if (buffer->buffer == NULL)
{
goto fail;
}
/* print the value */
if (!print_value(item, buffer))
{
goto fail;
}
update_offset(buffer);
/* check if reallocate is available */
if (hooks->reallocate != NULL)
{
printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
buffer->buffer = NULL;
if (printed == NULL) {
goto fail;
}
}
else /* otherwise copy the JSON over to a new buffer */
{
printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
if (printed == NULL)
{
goto fail;
}
memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
printed[buffer->offset] = '\0'; /* just to be sure */
/* free the buffer */
hooks->deallocate(buffer->buffer);
}
return printed;
fail:
if (buffer->buffer != NULL)
{
hooks->deallocate(buffer->buffer);
}
if (printed != NULL)
{
hooks->deallocate(printed);
}
return NULL;
}
/* Render a cJSON item/entity/structure to text. */
CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)
{
return (char*)print(item, true, &global_hooks);
}
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)
{
return (char*)print(item, false, &global_hooks);
}
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
if (prebuffer < 0)
{
return NULL;
}
p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
if (!p.buffer)
{
return NULL;
}
p.length = (size_t)prebuffer;
p.offset = 0;
p.noalloc = false;
p.format = fmt;
p.hooks = global_hooks;
if (!print_value(item, &p))
{
global_hooks.deallocate(p.buffer);
return NULL;
}
return (char*)p.buffer;
}
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt)
{
printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
if ((len < 0) || (buf == NULL))
{
return false;
}
p.buffer = (unsigned char*)buf;
p.length = (size_t)len;
p.offset = 0;
p.noalloc = true;
p.format = fmt;
p.hooks = global_hooks;
return print_value(item, &p);
}
/* Parser core - when encountering text, process appropriately. */
static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
{
if ((input_buffer == NULL) || (input_buffer->content == NULL))
{
return false; /* no input */
}
/* parse the different types of values */
/* null */
if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
{
item->type = cJSON_NULL;
input_buffer->offset += 4;
return true;
}
/* false */
if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
{
item->type = cJSON_False;
input_buffer->offset += 5;
return true;
}
/* true */
if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
{
item->type = cJSON_True;
item->valueint = 1;
input_buffer->offset += 4;
return true;
}
/* string */
if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
{
return parse_string(item, input_buffer);
}
/* number */
if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
{
return parse_number(item, input_buffer);
}
/* array */
if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
{
return parse_array(item, input_buffer);
}
/* object */
if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
{
return parse_object(item, input_buffer);
}
return false;
}
/* Render a value to text. */
static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output = NULL;
if ((item == NULL) || (output_buffer == NULL))
{
return false;
}
switch ((item->type) & 0xFF)
{
case cJSON_NULL:
output = ensure(output_buffer, 5);
if (output == NULL)
{
return false;
}
strcpy((char*)output, "null");
return true;
case cJSON_False:
output = ensure(output_buffer, 6);
if (output == NULL)
{
return false;
}
strcpy((char*)output, "false");
return true;
case cJSON_True:
output = ensure(output_buffer, 5);
if (output == NULL)
{
return false;
}
strcpy((char*)output, "true");
return true;
case cJSON_Number:
return print_number(item, output_buffer);
case cJSON_Raw:
{
size_t raw_length = 0;
if (item->valuestring == NULL)
{
return false;
}
raw_length = strlen(item->valuestring) + sizeof("");
output = ensure(output_buffer, raw_length);
if (output == NULL)
{
return false;
}
memcpy(output, item->valuestring, raw_length);
return true;
}
case cJSON_String:
return print_string(item, output_buffer);
case cJSON_Array:
return print_array(item, output_buffer);
case cJSON_Object:
return print_object(item, output_buffer);
default:
return false;
}
}
/* Build an array from input text. */
static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
{
cJSON *head = NULL; /* head of the linked list */
cJSON *current_item = NULL;
if (input_buffer->depth >= CJSON_NESTING_LIMIT)
{
return false; /* to deeply nested */
}
input_buffer->depth++;
if (buffer_at_offset(input_buffer)[0] != '[')
{
/* not an array */
goto fail;
}
input_buffer->offset++;
buffer_skip_whitespace(input_buffer);
if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
{
/* empty array */
goto success;
}
/* check if we skipped to the end of the buffer */
if (cannot_access_at_index(input_buffer, 0))
{
input_buffer->offset--;
goto fail;
}
/* step back to character in front of the first element */
input_buffer->offset--;
/* loop through the comma separated array elements */
do
{
/* allocate next item */
cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
if (new_item == NULL)
{
goto fail; /* allocation failure */
}
/* attach next item to list */
if (head == NULL)
{
/* start the linked list */
current_item = head = new_item;
}
else
{
/* add to the end and advance */
current_item->next = new_item;
new_item->prev = current_item;
current_item = new_item;
}
/* parse next value */
input_buffer->offset++;
buffer_skip_whitespace(input_buffer);
if (!parse_value(current_item, input_buffer))
{
goto fail; /* failed to parse value */
}
buffer_skip_whitespace(input_buffer);
}
while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
{
goto fail; /* expected end of array */
}
success:
input_buffer->depth--;
item->type = cJSON_Array;
item->child = head;
input_buffer->offset++;
return true;
fail:
if (head != NULL)
{
cJSON_Delete(head);
}
return false;
}
/* Render an array to text */
static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output_pointer = NULL;
size_t length = 0;
cJSON *current_element = item->child;
if (output_buffer == NULL)
{
return false;
}
/* Compose the output array. */
/* opening square bracket */
output_pointer = ensure(output_buffer, 1);
if (output_pointer == NULL)
{
return false;
}
*output_pointer = '[';
output_buffer->offset++;
output_buffer->depth++;
while (current_element != NULL)
{
if (!print_value(current_element, output_buffer))
{
return false;
}
update_offset(output_buffer);
if (current_element->next)
{
length = (size_t) (output_buffer->format ? 2 : 1);
output_pointer = ensure(output_buffer, length + 1);
if (output_pointer == NULL)
{
return false;
}
*output_pointer++ = ',';
if(output_buffer->format)
{
*output_pointer++ = ' ';
}
*output_pointer = '\0';
output_buffer->offset += length;
}
current_element = current_element->next;
}
output_pointer = ensure(output_buffer, 2);
if (output_pointer == NULL)
{
return false;
}
*output_pointer++ = ']';
*output_pointer = '\0';
output_buffer->depth--;
return true;
}
/* Build an object from the text. */
static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
{
cJSON *head = NULL; /* linked list head */
cJSON *current_item = NULL;
if (input_buffer->depth >= CJSON_NESTING_LIMIT)
{
return false; /* to deeply nested */
}
input_buffer->depth++;
if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
{
goto fail; /* not an object */
}
input_buffer->offset++;
buffer_skip_whitespace(input_buffer);
if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
{
goto success; /* empty object */
}
/* check if we skipped to the end of the buffer */
if (cannot_access_at_index(input_buffer, 0))
{
input_buffer->offset--;
goto fail;
}
/* step back to character in front of the first element */
input_buffer->offset--;
/* loop through the comma separated array elements */
do
{
/* allocate next item */
cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
if (new_item == NULL)
{
goto fail; /* allocation failure */
}
/* attach next item to list */
if (head == NULL)
{
/* start the linked list */
current_item = head = new_item;
}
else
{
/* add to the end and advance */
current_item->next = new_item;
new_item->prev = current_item;
current_item = new_item;
}
/* parse the name of the child */
input_buffer->offset++;
buffer_skip_whitespace(input_buffer);
if (!parse_string(current_item, input_buffer))
{
goto fail; /* faile to parse name */
}
buffer_skip_whitespace(input_buffer);
/* swap valuestring and string, because we parsed the name */
current_item->string = current_item->valuestring;
current_item->valuestring = NULL;
if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
{
goto fail; /* invalid object */
}
/* parse the value */
input_buffer->offset++;
buffer_skip_whitespace(input_buffer);
if (!parse_value(current_item, input_buffer))
{
goto fail; /* failed to parse value */
}
buffer_skip_whitespace(input_buffer);
}
while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
{
goto fail; /* expected end of object */
}
success:
input_buffer->depth--;
item->type = cJSON_Object;
item->child = head;
input_buffer->offset++;
return true;
fail:
if (head != NULL)
{
cJSON_Delete(head);
}
return false;
}
/* Render an object to text. */
static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output_pointer = NULL;
size_t length = 0;
cJSON *current_item = item->child;
if (output_buffer == NULL)
{
return false;
}
/* Compose the output: */
length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
output_pointer = ensure(output_buffer, length + 1);
if (output_pointer == NULL)
{
return false;
}
*output_pointer++ = '{';
output_buffer->depth++;
if (output_buffer->format)
{
*output_pointer++ = '\n';
}
output_buffer->offset += length;
while (current_item)
{
if (output_buffer->format)
{
size_t i;
output_pointer = ensure(output_buffer, output_buffer->depth);
if (output_pointer == NULL)
{
return false;
}
for (i = 0; i < output_buffer->depth; i++)
{
*output_pointer++ = '\t';
}
output_buffer->offset += output_buffer->depth;
}
/* print key */
if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
{
return false;
}
update_offset(output_buffer);
length = (size_t) (output_buffer->format ? 2 : 1);
output_pointer = ensure(output_buffer, length);
if (output_pointer == NULL)
{
return false;
}
*output_pointer++ = ':';
if (output_buffer->format)
{
*output_pointer++ = '\t';
}
output_buffer->offset += length;
/* print value */
if (!print_value(current_item, output_buffer))
{
return false;
}
update_offset(output_buffer);
/* print comma if not last */
length = (size_t) ((output_buffer->format ? 1 : 0) + (current_item->next ? 1 : 0));
output_pointer = ensure(output_buffer, length + 1);
if (output_pointer == NULL)
{
return false;
}
if (current_item->next)
{
*output_pointer++ = ',';
}
if (output_buffer->format)
{
*output_pointer++ = '\n';
}
*output_pointer = '\0';
output_buffer->offset += length;
current_item = current_item->next;
}
output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
if (output_pointer == NULL)
{
return false;
}
if (output_buffer->format)
{
size_t i;
for (i = 0; i < (output_buffer->depth - 1); i++)
{
*output_pointer++ = '\t';
}
}
*output_pointer++ = '}';
*output_pointer = '\0';
output_buffer->depth--;
return true;
}
/* Get Array size/item / object item. */
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
{
cJSON *child = NULL;
size_t size = 0;
if (array == NULL)
{
return 0;
}
child = array->child;
while(child != NULL)
{
size++;
child = child->next;
}
/* FIXME: Can overflow here. Cannot be fixed without breaking the API */
return (int)size;
}
static cJSON* get_array_item(const cJSON *array, size_t index)
{
cJSON *current_child = NULL;
if (array == NULL)
{
return NULL;
}
current_child = array->child;
while ((current_child != NULL) && (index > 0))
{
index--;
current_child = current_child->next;
}
return current_child;
}
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
{
if (index < 0)
{
return NULL;
}
return get_array_item(array, (size_t)index);
}
static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
cJSON *current_element = NULL;
if ((object == NULL) || (name == NULL))
{
return NULL;
}
current_element = object->child;
if (case_sensitive)
{
while ((current_element != NULL) && (strcmp(name, current_element->string) != 0))
{
current_element = current_element->next;
}
}
else
{
while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
{
current_element = current_element->next;
}
}
return current_element;
}
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)
{
return get_object_item(object, string, false);
}
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)
{
return get_object_item(object, string, true);
}
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)
{
return cJSON_GetObjectItem(object, string) ? 1 : 0;
}
/* Utility for array list handling. */
static void suffix_object(cJSON *prev, cJSON *item)
{
prev->next = item;
item->prev = prev;
}
/* Utility for handling references. */
static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
{
cJSON *reference = NULL;
if (item == NULL)
{
return NULL;
}
reference = cJSON_New_Item(hooks);
if (reference == NULL)
{
return NULL;
}
memcpy(reference, item, sizeof(cJSON));
reference->string = NULL;
reference->type |= cJSON_IsReference;
reference->next = reference->prev = NULL;
return reference;
}
static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
{
cJSON *child = NULL;
if ((item == NULL) || (array == NULL))
{
return false;
}
child = array->child;
if (child == NULL)
{
/* list is empty, start new one */
array->child = item;
}
else
{
/* append to the end */
while (child->next)
{
child = child->next;
}
suffix_object(child, item);
}
return true;
}
/* Add item to array/object. */
CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
{
add_item_to_array(array, item);
}
#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
#pragma GCC diagnostic push
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
/* helper function to cast away const */
static void* cast_away_const(const void* string)
{
return (void*)string;
}
#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
#pragma GCC diagnostic pop
#endif
static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
{
if ((object == NULL) || (string == NULL) || (item == NULL))
{
return false;
}
if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
{
hooks->deallocate(item->string);
}
if (constant_key)
{
item->string = (char*)cast_away_const(string);
item->type |= cJSON_StringIsConst;
}
else
{
char *key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
if (key == NULL)
{
return false;
}
item->string = key;
item->type &= ~cJSON_StringIsConst;
}
return add_item_to_array(object, item);
}
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
{
add_item_to_object(object, string, item, &global_hooks, false);
}
/* Add an item to an object with constant string as key */
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
{
add_item_to_object(object, string, item, &global_hooks, true);
}
CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
{
if (array == NULL)
{
return;
}
add_item_to_array(array, create_reference(item, &global_hooks));
}
CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
{
if ((object == NULL) || (string == NULL))
{
return;
}
add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
}
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
{
cJSON *null = cJSON_CreateNull();
if (add_item_to_object(object, name, null, &global_hooks, false))
{
return null;
}
cJSON_Delete(null);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
{
cJSON *true_item = cJSON_CreateTrue();
if (add_item_to_object(object, name, true_item, &global_hooks, false))
{
return true_item;
}
cJSON_Delete(true_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
{
cJSON *false_item = cJSON_CreateFalse();
if (add_item_to_object(object, name, false_item, &global_hooks, false))
{
return false_item;
}
cJSON_Delete(false_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
{
cJSON *bool_item = cJSON_CreateBool(boolean);
if (add_item_to_object(object, name, bool_item, &global_hooks, false))
{
return bool_item;
}
cJSON_Delete(bool_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
{
cJSON *number_item = cJSON_CreateNumber(number);
if (add_item_to_object(object, name, number_item, &global_hooks, false))
{
return number_item;
}
cJSON_Delete(number_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
{
cJSON *string_item = cJSON_CreateString(string);
if (add_item_to_object(object, name, string_item, &global_hooks, false))
{
return string_item;
}
cJSON_Delete(string_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
{
cJSON *raw_item = cJSON_CreateRaw(raw);
if (add_item_to_object(object, name, raw_item, &global_hooks, false))
{
return raw_item;
}
cJSON_Delete(raw_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
{
cJSON *object_item = cJSON_CreateObject();
if (add_item_to_object(object, name, object_item, &global_hooks, false))
{
return object_item;
}
cJSON_Delete(object_item);
return NULL;
}
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
{
cJSON *array = cJSON_CreateArray();
if (add_item_to_object(object, name, array, &global_hooks, false))
{
return array;
}
cJSON_Delete(array);
return NULL;
}
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
{
if ((parent == NULL) || (item == NULL))
{
return NULL;
}
if (item->prev != NULL)
{
/* not the first element */
item->prev->next = item->next;
}
if (item->next != NULL)
{
/* not the last element */
item->next->prev = item->prev;
}
if (item == parent->child)
{
/* first element */
parent->child = item->next;
}
/* make sure the detached item doesn't point anywhere anymore */
item->prev = NULL;
item->next = NULL;
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)
{
if (which < 0)
{
return NULL;
}
return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
}
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)
{
cJSON_Delete(cJSON_DetachItemFromArray(array, which));
}
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
{
cJSON *to_detach = cJSON_GetObjectItem(object, string);
return cJSON_DetachItemViaPointer(object, to_detach);
}
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
{
cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
return cJSON_DetachItemViaPointer(object, to_detach);
}
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)
{
cJSON_Delete(cJSON_DetachItemFromObject(object, string));
}
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)
{
cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
}
/* Replace array/object items with new ones. */
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
cJSON *after_inserted = NULL;
if (which < 0)
{
return;
}
after_inserted = get_array_item(array, (size_t)which);
if (after_inserted == NULL)
{
add_item_to_array(array, newitem);
return;
}
newitem->next = after_inserted;
newitem->prev = after_inserted->prev;
after_inserted->prev = newitem;
if (after_inserted == array->child)
{
array->child = newitem;
}
else
{
newitem->prev->next = newitem;
}
}
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
{
if ((parent == NULL) || (replacement == NULL) || (item == NULL))
{
return false;
}
if (replacement == item)
{
return true;
}
replacement->next = item->next;
replacement->prev = item->prev;
if (replacement->next != NULL)
{
replacement->next->prev = replacement;
}
if (replacement->prev != NULL)
{
replacement->prev->next = replacement;
}
if (parent->child == item)
{
parent->child = replacement;
}
item->next = NULL;
item->prev = NULL;
cJSON_Delete(item);
return true;
}
CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
{
if (which < 0)
{
return;
}
cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
}
static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
{
if ((replacement == NULL) || (string == NULL))
{
return false;
}
/* replace the name in the replacement */
if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
{
cJSON_free(replacement->string);
}
replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
replacement->type &= ~cJSON_StringIsConst;
cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
return true;
}
CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
{
replace_item_in_object(object, string, newitem, false);
}
CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)
{
replace_item_in_object(object, string, newitem, true);
}
/* Create basic types: */
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_NULL;
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_True;
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_False;
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool b)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = b ? cJSON_True : cJSON_False;
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_Number;
item->valuedouble = num;
/* use saturation in case of overflow */
if (num >= INT_MAX)
{
item->valueint = INT_MAX;
}
else if (num <= INT_MIN)
{
item->valueint = INT_MIN;
}
else
{
item->valueint = (int)num;
}
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_String;
item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
if(!item->valuestring)
{
cJSON_Delete(item);
return NULL;
}
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if (item != NULL)
{
item->type = cJSON_String | cJSON_IsReference;
item->valuestring = (char*)cast_away_const(string);
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if (item != NULL) {
item->type = cJSON_Object | cJSON_IsReference;
item->child = (cJSON*)cast_away_const(child);
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
cJSON *item = cJSON_New_Item(&global_hooks);
if (item != NULL) {
item->type = cJSON_Array | cJSON_IsReference;
item->child = (cJSON*)cast_away_const(child);
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_Raw;
item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
if(!item->valuestring)
{
cJSON_Delete(item);
return NULL;
}
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type=cJSON_Array;
}
return item;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if (item)
{
item->type = cJSON_Object;
}
return item;
}
/* Create Arrays: */
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
{
size_t i = 0;
cJSON *n = NULL;
cJSON *p = NULL;
cJSON *a = NULL;
if ((count < 0) || (numbers == NULL))
{
return NULL;
}
a = cJSON_CreateArray();
for(i = 0; a && (i < (size_t)count); i++)
{
n = cJSON_CreateNumber(numbers[i]);
if (!n)
{
cJSON_Delete(a);
return NULL;
}
if(!i)
{
a->child = n;
}
else
{
suffix_object(p, n);
}
p = n;
}
return a;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
{
size_t i = 0;
cJSON *n = NULL;
cJSON *p = NULL;
cJSON *a = NULL;
if ((count < 0) || (numbers == NULL))
{
return NULL;
}
a = cJSON_CreateArray();
for(i = 0; a && (i < (size_t)count); i++)
{
n = cJSON_CreateNumber((double)numbers[i]);
if(!n)
{
cJSON_Delete(a);
return NULL;
}
if(!i)
{
a->child = n;
}
else
{
suffix_object(p, n);
}
p = n;
}
return a;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)
{
size_t i = 0;
cJSON *n = NULL;
cJSON *p = NULL;
cJSON *a = NULL;
if ((count < 0) || (numbers == NULL))
{
return NULL;
}
a = cJSON_CreateArray();
for(i = 0;a && (i < (size_t)count); i++)
{
n = cJSON_CreateNumber(numbers[i]);
if(!n)
{
cJSON_Delete(a);
return NULL;
}
if(!i)
{
a->child = n;
}
else
{
suffix_object(p, n);
}
p = n;
}
return a;
}
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count)
{
size_t i = 0;
cJSON *n = NULL;
cJSON *p = NULL;
cJSON *a = NULL;
if ((count < 0) || (strings == NULL))
{
return NULL;
}
a = cJSON_CreateArray();
for (i = 0; a && (i < (size_t)count); i++)
{
n = cJSON_CreateString(strings[i]);
if(!n)
{
cJSON_Delete(a);
return NULL;
}
if(!i)
{
a->child = n;
}
else
{
suffix_object(p,n);
}
p = n;
}
return a;
}
/* Duplication */
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
{
cJSON *newitem = NULL;
cJSON *child = NULL;
cJSON *next = NULL;
cJSON *newchild = NULL;
/* Bail on bad ptr */
if (!item)
{
goto fail;
}
/* Create new item */
newitem = cJSON_New_Item(&global_hooks);
if (!newitem)
{
goto fail;
}
/* Copy over all vars */
newitem->type = item->type & (~cJSON_IsReference);
newitem->valueint = item->valueint;
newitem->valuedouble = item->valuedouble;
if (item->valuestring)
{
newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks);
if (!newitem->valuestring)
{
goto fail;
}
}
if (item->string)
{
newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks);
if (!newitem->string)
{
goto fail;
}
}
/* If non-recursive, then we're done! */
if (!recurse)
{
return newitem;
}
/* Walk the ->next chain for the child. */
child = item->child;
while (child != NULL)
{
newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
if (!newchild)
{
goto fail;
}
if (next != NULL)
{
/* If newitem->child already set, then crosswire ->prev and ->next and move on */
next->next = newchild;
newchild->prev = next;
next = newchild;
}
else
{
/* Set newitem->child and move to it */
newitem->child = newchild;
next = newchild;
}
child = child->next;
}
return newitem;
fail:
if (newitem != NULL)
{
cJSON_Delete(newitem);
}
return NULL;
}
CJSON_PUBLIC(void) cJSON_Minify(char *json)
{
unsigned char *into = (unsigned char*)json;
if (json == NULL)
{
return;
}
while (*json)
{
if (*json == ' ')
{
json++;
}
else if (*json == '\t')
{
/* Whitespace characters. */
json++;
}
else if (*json == '\r')
{
json++;
}
else if (*json=='\n')
{
json++;
}
else if ((*json == '/') && (json[1] == '/'))
{
/* double-slash comments, to end of line. */
while (*json && (*json != '\n'))
{
json++;
}
}
else if ((*json == '/') && (json[1] == '*'))
{
/* multiline comments. */
while (*json && !((*json == '*') && (json[1] == '/')))
{
json++;
}
json += 2;
}
else if (*json == '\"')
{
/* string literals, which are \" sensitive. */
*into++ = (unsigned char)*json++;
while (*json && (*json != '\"'))
{
if (*json == '\\')
{
*into++ = (unsigned char)*json++;
}
*into++ = (unsigned char)*json++;
}
*into++ = (unsigned char)*json++;
}
else
{
/* All other characters. */
*into++ = (unsigned char)*json++;
}
}
/* and null-terminate. */
*into = '\0';
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_Invalid;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_False;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xff) == cJSON_True;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & (cJSON_True | cJSON_False)) != 0;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_NULL;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_Number;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_String;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_Array;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_Object;
}
CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)
{
if (item == NULL)
{
return false;
}
return (item->type & 0xFF) == cJSON_Raw;
}
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)
{
if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a))
{
return false;
}
/* check if type is valid */
switch (a->type & 0xFF)
{
case cJSON_False:
case cJSON_True:
case cJSON_NULL:
case cJSON_Number:
case cJSON_String:
case cJSON_Raw:
case cJSON_Array:
case cJSON_Object:
break;
default:
return false;
}
/* identical objects are equal */
if (a == b)
{
return true;
}
switch (a->type & 0xFF)
{
/* in these cases and equal type is enough */
case cJSON_False:
case cJSON_True:
case cJSON_NULL:
return true;
case cJSON_Number:
if (a->valuedouble == b->valuedouble)
{
return true;
}
return false;
case cJSON_String:
case cJSON_Raw:
if ((a->valuestring == NULL) || (b->valuestring == NULL))
{
return false;
}
if (strcmp(a->valuestring, b->valuestring) == 0)
{
return true;
}
return false;
case cJSON_Array:
{
cJSON *a_element = a->child;
cJSON *b_element = b->child;
for (; (a_element != NULL) && (b_element != NULL);)
{
if (!cJSON_Compare(a_element, b_element, case_sensitive))
{
return false;
}
a_element = a_element->next;
b_element = b_element->next;
}
/* one of the arrays is longer than the other */
if (a_element != b_element) {
return false;
}
return true;
}
case cJSON_Object:
{
cJSON *a_element = NULL;
cJSON *b_element = NULL;
cJSON_ArrayForEach(a_element, a)
{
/* TODO This has O(n^2) runtime, which is horrible! */
b_element = get_object_item(b, a_element->string, case_sensitive);
if (b_element == NULL)
{
return false;
}
if (!cJSON_Compare(a_element, b_element, case_sensitive))
{
return false;
}
}
/* doing this twice, once on a and b to prevent true comparison if a subset of b
* TODO: Do this the proper way, this is just a fix for now */
cJSON_ArrayForEach(b_element, b)
{
a_element = get_object_item(a, b_element->string, case_sensitive);
if (a_element == NULL)
{
return false;
}
if (!cJSON_Compare(b_element, a_element, case_sensitive))
{
return false;
}
}
return true;
}
default:
return false;
}
}
CJSON_PUBLIC(void *) cJSON_malloc(size_t size)
{
return global_hooks.allocate(size);
}
CJSON_PUBLIC(void) cJSON_free(void *object)
{
global_hooks.deallocate(object);
}
mapcache-rel-1-14-1/lib/cache.c 0000664 0000000 0000000 00000017156 14653160677 0016123 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapServer
* Purpose: MapCache tile caching: generic cache access
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2015 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without compositeriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#include
int mapcache_cache_tile_get(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile) {
int i,rv;
mapcache_rule *rule = mapcache_ruleset_rule_get(tile->grid_link->rules, tile->z);
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"calling tile_get on cache (%s): (tileset=%s, grid=%s, z=%d, x=%d, y=%d",cache->name,tile->tileset->name,tile->grid_link->grid->name,tile->z,tile->x, tile->y);
#endif
/* if tile is outside visible limits, return a blank tile */
if (mapcache_ruleset_is_visible_tile(rule, tile) == MAPCACHE_FALSE) {
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
mapcache_buffer_append(tile->encoded_data, rule->hidden_tile->size, rule->hidden_tile->buf);
return MAPCACHE_SUCCESS;
}
for(i=0;i<=cache->retry_count;i++) {
if(i) {
ctx->log(ctx,MAPCACHE_INFO,"cache (%s) get retry %d of %d. previous try returned error: %s",cache->name,i,cache->retry_count,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
if(cache->retry_delay > 0) {
double wait = cache->retry_delay;
int j = 0;
for(j=1;j_tile_get(ctx,cache,tile);
if(!GC_HAS_ERROR(ctx))
break;
}
return rv;
}
void mapcache_cache_tile_delete(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile) {
int i;
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"calling tile_delete on cache (%s): (tileset=%s, grid=%s, z=%d, x=%d, y=%d",cache->name,tile->tileset->name,tile->grid_link->grid->name,tile->z,tile->x, tile->y);
#endif
if(tile->tileset->read_only)
return;
for(i=0;i<=cache->retry_count;i++) {
if(i) {
ctx->log(ctx,MAPCACHE_INFO,"cache (%s) delete retry %d of %d. previous try returned error: %s",cache->name,i,cache->retry_count,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
if(cache->retry_delay > 0) {
double wait = cache->retry_delay;
int j = 0;
for(j=1;j_tile_delete(ctx,cache,tile);
if(!GC_HAS_ERROR(ctx))
break;
}
}
int mapcache_cache_tile_exists(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile) {
int i,rv;
mapcache_rule *rule = mapcache_ruleset_rule_get(tile->grid_link->rules, tile->z);
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"calling tile_exists on cache (%s): (tileset=%s, grid=%s, z=%d, x=%d, y=%d",cache->name,tile->tileset->name,tile->grid_link->grid->name,tile->z,tile->x, tile->y);
#endif
/* if tile is outside visible limits return TRUE
a blank tile will be returned on subsequent get call on cache */
if (mapcache_ruleset_is_visible_tile(rule, tile) == MAPCACHE_FALSE) {
return MAPCACHE_TRUE;
}
for(i=0;i<=cache->retry_count;i++) {
if(i) {
ctx->log(ctx,MAPCACHE_INFO,"cache (%s) exists retry %d of %d. previous try returned error: %s",cache->name,i,cache->retry_count,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
if(cache->retry_delay > 0) {
double wait = cache->retry_delay;
int j = 0;
for(j=1;j_tile_exists(ctx,cache,tile);
if(!GC_HAS_ERROR(ctx))
break;
}
return rv;
}
void mapcache_cache_tile_set(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tile) {
int i;
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"calling tile_set on cache (%s): (tileset=%s, grid=%s, z=%d, x=%d, y=%d",cache->name,tile->tileset->name,tile->grid_link->grid->name,tile->z,tile->x, tile->y);
#endif
if(tile->tileset->read_only)
return;
for(i=0;i<=cache->retry_count;i++) {
if(i) {
ctx->log(ctx,MAPCACHE_INFO,"cache (%s) set retry %d of %d. previous try returned error: %s",cache->name,i,cache->retry_count,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
if(cache->retry_delay > 0) {
double wait = cache->retry_delay;
int j = 0;
for(j=1;j_tile_set(ctx,cache,tile);
if(!GC_HAS_ERROR(ctx))
break;
}
}
void mapcache_cache_tile_multi_set(mapcache_context *ctx, mapcache_cache *cache, mapcache_tile *tiles, int ntiles) {
int i;
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"calling tile_multi_set on cache (%s): (tileset=%s, grid=%s, first tile: z=%d, x=%d, y=%d",cache->name,tiles[0].tileset->name,tiles[0].grid_link->grid->name,
tiles[0].z,tiles[0].x, tiles[0].y);
#endif
if((&tiles[0])->tileset->read_only)
return;
if(cache->_tile_multi_set) {
for(i=0;i<=cache->retry_count;i++) {
if(i) {
ctx->log(ctx,MAPCACHE_INFO,"cache (%s) multi-set retry %d of %d. previous try returned error: %s",cache->name,i,cache->retry_count,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
if(cache->retry_delay > 0) {
double wait = cache->retry_delay;
int j = 0;
for(j=1;j_tile_multi_set(ctx,cache,tiles,ntiles);
if(!GC_HAS_ERROR(ctx))
break;
}
} else {
for( i=0;icaches);
while(cachei) {
mapcache_cache *cache;
const void *key;
apr_ssize_t keylen;
apr_hash_this(cachei,&key,&keylen,(void**)&cache);
cache->child_init(ctx,cache,pchild);
cachei = apr_hash_next(cachei);
}
}
mapcache-rel-1-14-1/lib/cache_bdb.c 0000664 0000000 0000000 00000034722 14653160677 0016730 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapCache
* Purpose: MapCache tile caching support file: Berkeley DB cache backend
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_BDB
#include
#include
#include
#include
#include
#include
#include
#ifdef APR_HAS_THREADS
#include
#endif
#ifndef _WIN32
#include
#endif
#include
#define PAGESIZE 64*1024
#define CACHESIZE 1024*1024
typedef struct mapcache_cache_bdb mapcache_cache_bdb;
struct mapcache_cache_bdb {
mapcache_cache cache;
char *basedir;
char *key_template;
};
struct bdb_env {
DB* db;
DB_ENV *env;
int readonly;
char *errmsg;
};
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 = 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));
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));
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));
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));
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));
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));
goto cleanup_error;
}
goto cleanup;
cleanup_error:
free(benv);
cleanup:
free(dbfile);
}
void mapcache_bdb_connection_destructor(void *conn_)
{
struct bdb_env *benv = (struct bdb_env*)conn_;
benv->db->close(benv->db,0);
benv->env->close(benv->env,0);
free(benv);
}
static mapcache_pooled_connection* _bdb_get_conn(mapcache_context *ctx, mapcache_cache_bdb *cache, mapcache_tile* tile, int readonly) {
struct bdb_env *benv;
mapcache_pooled_connection *pc;
char *conn_key = apr_pstrcat(ctx->pool,readonly?"ro_":"rw_",cache->cache.name,NULL);
pc = mapcache_connection_pool_get_connection(ctx,conn_key,mapcache_bdb_connection_constructor, mapcache_bdb_connection_destructor, cache);
if(GC_HAS_ERROR(ctx)) return NULL;
benv = pc->connection;
benv->readonly = readonly;
return pc;
}
static void _bdb_release_conn(mapcache_context *ctx, mapcache_cache_bdb *cache, mapcache_tile *tile, mapcache_pooled_connection *pc)
{
if(GC_HAS_ERROR(ctx)) {
mapcache_connection_pool_invalidate_connection(ctx, pc);
} else {
mapcache_connection_pool_release_connection(ctx,pc);
}
}
static int _mapcache_cache_bdb_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
int ret;
DBT key;
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;
pc = _bdb_get_conn(ctx,cache,tile,1);
if(GC_HAS_ERROR(ctx)) return MAPCACHE_FALSE;
benv = pc->connection;
memset(&key, 0, sizeof(DBT));
key.data = skey;
key.size = strlen(skey)+1;
ret = benv->db->exists(benv->db, NULL, &key, 0);
if(ret == 0) {
ret = MAPCACHE_TRUE;
} else if(ret == DB_NOTFOUND) {
ret = MAPCACHE_FALSE;
} else {
ctx->set_error(ctx,500,"bdb backend failure on tile_exists: %s",db_strerror(ret));
ret= MAPCACHE_FALSE;
}
_bdb_release_conn(ctx,cache,tile,pc);
return ret;
}
static void _mapcache_cache_bdb_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
DBT key;
int ret;
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;
pc = _bdb_get_conn(ctx,cache,tile,0);
GC_CHECK_ERROR(ctx);
benv = pc->connection;
memset(&key, 0, sizeof(DBT));
key.data = skey;
key.size = strlen(skey)+1;
ret = benv->db->del(benv->db, NULL, &key, 0);
if(ret && ret != DB_NOTFOUND) {
ctx->set_error(ctx,500,"bdb backend failure on tile_delete: %s",db_strerror(ret));
} else {
ret = benv->db->sync(benv->db,0);
if(ret)
ctx->set_error(ctx,500,"bdb backend sync failure on tile_delete: %s",db_strerror(ret));
}
_bdb_release_conn(ctx,cache,tile,pc);
}
static int _mapcache_cache_bdb_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
DBT key,data;
int ret;
char *skey;
mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache;
mapcache_pooled_connection *pc;
struct bdb_env *benv;
pc = _bdb_get_conn(ctx,cache,tile,1);
if(GC_HAS_ERROR(ctx)) return MAPCACHE_FALSE;
benv = pc->connection;
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;
key.data = skey;
key.size = strlen(skey)+1;
ret = benv->db->get(benv->db, NULL, &key, &data, 0);
if(ret == 0) {
if(((char*)(data.data))[0] == '#') {
tile->encoded_data = mapcache_empty_png_decode(ctx,tile->grid_link->grid->tile_sx, tile->grid_link->grid->tile_sy, (unsigned char*)data.data,&tile->nodata);
} else {
tile->encoded_data = mapcache_buffer_create(0,ctx->pool);
tile->encoded_data->buf = data.data;
tile->encoded_data->size = data.size-sizeof(apr_time_t);
tile->encoded_data->avail = data.size;
apr_pool_cleanup_register(ctx->pool, tile->encoded_data->buf,(void*)free, apr_pool_cleanup_null);
}
tile->mtime = *((apr_time_t*)(((char*)data.data)+data.size-sizeof(apr_time_t)));
ret = MAPCACHE_SUCCESS;
} else if(ret == DB_NOTFOUND) {
ret = MAPCACHE_CACHE_MISS;
} else {
ctx->set_error(ctx,500,"bdb backend failure on tile_get: %s",db_strerror(ret));
ret = MAPCACHE_FAILURE;
}
_bdb_release_conn(ctx,cache,tile,pc);
return ret;
}
static void _mapcache_cache_bdb_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
DBT key,data;
int ret;
apr_time_t now;
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;
now = apr_time_now();
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = skey;
key.size = strlen(skey)+1;
if(!tile->raw_image) {
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);
(((char*)data.data)[0])='#';
memcpy(((char*)data.data)+1,tile->raw_image->data,4);
memcpy(((char*)data.data)+5,&now,sizeof(apr_time_t));
} else {
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
data.data = tile->encoded_data->buf;
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;
ret = benv->db->put(benv->db,NULL,&key,&data,0);
if(ret != 0) {
ctx->set_error(ctx,500,"dbd backend failed on tile_set: %s", db_strerror(ret));
} else {
ret = benv->db->sync(benv->db,0);
if(ret)
ctx->set_error(ctx,500,"bdb backend sync failure on tile_set: %s",db_strerror(ret));
}
_bdb_release_conn(ctx,cache,tile,pc);
}
static void _mapcache_cache_bdb_multiset(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
DBT key,data;
int ret,i;
apr_time_t now;
mapcache_cache_bdb *cache = (mapcache_cache_bdb*)pcache;
mapcache_pooled_connection *pc;
struct bdb_env *benv;
now = apr_time_now();
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
pc = _bdb_get_conn(ctx,cache,&tiles[0],0);
GC_CHECK_ERROR(ctx);
benv = pc->connection;
for(i=0; ikey_template,NULL,NULL);
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
if(GC_HAS_ERROR(ctx)) {
_bdb_release_conn(ctx,cache,&tiles[0],pc);
return;
}
}
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);
(((char*)data.data)[0])='#';
memcpy(((char*)data.data)+1,tile->raw_image->data,4);
memcpy(((char*)data.data)+5,&now,sizeof(apr_time_t));
} else {
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
if(GC_HAS_ERROR(ctx)) {
_bdb_release_conn(ctx,cache,&tiles[0],pc);
return;
}
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
data.data = tile->encoded_data->buf;
data.size = tile->encoded_data->size;
tile->encoded_data->size -= sizeof(apr_time_t);
}
key.data = skey;
key.size = strlen(skey)+1;
ret = benv->db->put(benv->db,NULL,&key,&data,0);
if(ret != 0) {
ctx->set_error(ctx,500,"dbd backend failed on tile_multiset: %s", db_strerror(ret));
break;
}
}
if(ret == 0) {
ret = benv->db->sync(benv->db,0);
if(ret)
ctx->set_error(ctx,500,"bdb backend sync failure on sync in tile_multiset: %s",db_strerror(ret));
}
_bdb_release_conn(ctx,cache,&tiles[0],pc);
}
static void _mapcache_cache_bdb_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_bdb *dcache = (mapcache_cache_bdb*)cache;
if ((cur_node = ezxml_child(node,"base")) != NULL) {
dcache->basedir = apr_pstrdup(ctx->pool,cur_node->txt);
}
if ((cur_node = ezxml_child(node,"key_template")) != NULL) {
dcache->key_template = apr_pstrdup(ctx->pool,cur_node->txt);
} else {
dcache->key_template = apr_pstrdup(ctx->pool,"{tileset}-{grid}-{dim}-{z}-{y}-{x}.{ext}");
}
if(!dcache->basedir) {
ctx->set_error(ctx,500,"dbd cache \"%s\" is missing entry",cache->name);
return;
}
}
/**
* \private \memberof mapcache_cache_dbd
*/
static void _mapcache_cache_bdb_configuration_post_config(mapcache_context *ctx,
mapcache_cache *cache, mapcache_cfg *cfg)
{
mapcache_cache_bdb *dcache = (mapcache_cache_bdb*)cache;
apr_status_t rv;
apr_dir_t *dir;
rv = apr_dir_open(&dir, dcache->basedir, ctx->pool);
if(rv != APR_SUCCESS) {
char errmsg[120];
ctx->set_error(ctx,500,"bdb failed to open directory %s:%s",dcache->basedir,apr_strerror(rv,errmsg,120));
}
}
/**
* \brief creates and initializes a mapcache_dbd_cache
*/
mapcache_cache* mapcache_cache_bdb_create(mapcache_context *ctx)
{
mapcache_cache_bdb *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_bdb));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate berkeley db cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_BDB;
cache->cache._tile_delete = _mapcache_cache_bdb_delete;
cache->cache._tile_get = _mapcache_cache_bdb_get;
cache->cache._tile_exists = _mapcache_cache_bdb_has_tile;
cache->cache._tile_set = _mapcache_cache_bdb_set;
cache->cache._tile_multi_set = _mapcache_cache_bdb_multiset;
cache->cache.configuration_post_config = _mapcache_cache_bdb_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_bdb_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->basedir = NULL;
cache->key_template = NULL;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_bdb_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"BERKELEYDB support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_composite.c 0000664 0000000 0000000 00000024755 14653160677 0020210 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapServer
* Purpose: MapCache tile caching: composite cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without compositeriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#include
typedef struct mapcache_cache_composite mapcache_cache_composite;
typedef struct mapcache_cache_composite_cache_link mapcache_cache_composite_cache_link;
struct mapcache_cache_composite_cache_link {
mapcache_cache *cache;
int minzoom;
int maxzoom;
apr_array_header_t *grids;
apr_table_t *dimensions; /* key/value pairs of dimensions */
};
struct mapcache_cache_composite {
mapcache_cache cache;
apr_array_header_t *cache_links;
};
static mapcache_cache_composite_cache_link* _mapcache_cache_link_create(apr_pool_t *pool) {
mapcache_cache_composite_cache_link *cl = apr_pcalloc(pool, sizeof(mapcache_cache_composite_cache_link));
cl->cache=NULL;
cl->dimensions=NULL;
cl->grids=NULL;
cl->maxzoom=-1;
cl->minzoom=-1;
return cl;
}
/**
* returns the mapcache_cache to use for a given tile
* @param ctx
* @param tile
* @return
*/
static mapcache_cache* _mapcache_composite_cache_get(mapcache_context *ctx, mapcache_cache_composite *cache, mapcache_tile *tile) {
int i;
for(i=0; icache_links->nelts; i++) {
mapcache_cache_composite_cache_link *cache_link = APR_ARRAY_IDX(cache->cache_links,i,mapcache_cache_composite_cache_link*);
if(cache_link->minzoom != -1 && tile->z < cache_link->minzoom) continue;
if(cache_link->maxzoom != -1 && tile->z > cache_link->maxzoom) continue;
if(cache_link->grids) {
int j;
for(j=0;jgrids->nelts;j++) {
char *grid_name = APR_ARRAY_IDX(cache_link->grids,j,char*);
if(!strcmp(tile->grid_link->grid->name,grid_name))
break;
}
/* not found */
if(j == cache_link->grids->nelts) continue;
}
if(cache_link->dimensions) {
const apr_array_header_t *array = apr_table_elts(cache_link->dimensions);
apr_table_entry_t *elts = (apr_table_entry_t *) array->elts;
int j;
if(!tile->dimensions) continue; /* the cache link refers to dimensions, but this tile does not have any, it cannot match */
for (j = 0; j < array->nelts; j++) {
char *dim = elts[j].key;
char *dimval = elts[j].val;
int k;
for(k=0;kdimensions->nelts;k++) {
mapcache_requested_dimension *rdim = APR_ARRAY_IDX(tile->dimensions,i,mapcache_requested_dimension*);
if(!strcmp(rdim->dimension->name,dim) && !strcmp(rdim->cached_value,dimval))
break;
}
if(k == tile->dimensions->nelts) break; /* no tile dimension matched the current cache dimension */
}
if(j != array->nelts) continue; /* we broke out early from the cache dimension loop, so at least one was not correct */
}
return cache_link->cache;
}
ctx->set_error(ctx, 500, "no cache matches for given tile request");
return NULL;
}
static int _mapcache_cache_composite_tile_exists(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
mapcache_cache *subcache;
subcache = _mapcache_composite_cache_get(ctx, cache, tile);
if(GC_HAS_ERROR(ctx) || !subcache)
return MAPCACHE_FAILURE;
return mapcache_cache_tile_exists(ctx, subcache, tile);
}
static void _mapcache_cache_composite_tile_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
mapcache_cache *subcache;
subcache = _mapcache_composite_cache_get(ctx, cache, tile);
GC_CHECK_ERROR(ctx);
/*delete the tile itself*/
mapcache_cache_tile_delete(ctx,subcache,tile);
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the composite server
* \private \memberof mapcache_cache_composite
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_composite_tile_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
mapcache_cache *subcache;
subcache = _mapcache_composite_cache_get(ctx, cache, tile);
GC_CHECK_ERROR_RETURN(ctx);
return mapcache_cache_tile_get(ctx,subcache,tile);
}
static void _mapcache_cache_composite_tile_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
mapcache_cache *subcache;
subcache = _mapcache_composite_cache_get(ctx, cache, tile);
GC_CHECK_ERROR(ctx);
return mapcache_cache_tile_set(ctx,subcache,tile);
}
static void _mapcache_cache_composite_tile_multi_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
mapcache_cache *subcache;
subcache = _mapcache_composite_cache_get(ctx, cache, &tiles[0]);
GC_CHECK_ERROR(ctx);
return mapcache_cache_tile_multi_set(ctx,subcache,tiles,ntiles);
}
/**
* \private \memberof mapcache_cache_composite
*/
static void _mapcache_cache_composite_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *pcache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_composite *cache = (mapcache_cache_composite*)pcache;
cache->cache_links = apr_array_make(ctx->pool,3,sizeof(mapcache_cache_composite_cache_link*));
for(cur_node = ezxml_child(node,"cache"); cur_node; cur_node = cur_node->next) {
char *sZoom;
int zoom;
mapcache_cache *refcache = mapcache_configuration_get_cache(config, cur_node->txt);
mapcache_cache_composite_cache_link *cachelink;
if(!refcache) {
ctx->set_error(ctx, 400, "composite cache \"%s\" references cache \"%s\","
" but it is not configured (hint:referenced caches must be declared before this composite cache in the xml file)", pcache->name, cur_node->txt);
return;
}
cachelink = _mapcache_cache_link_create(ctx->pool);
cachelink->cache = refcache;
sZoom = (char*)ezxml_attr(cur_node,"max-zoom");
if(sZoom) {
char *endptr;
zoom = (int)strtol(sZoom,&endptr,10);
if(*endptr != 0 || zoom < 0) {
ctx->set_error(ctx, 400, "failed to parse cache max-zoom %s (expecting a positive integer)",
sZoom);
return;
}
cachelink->maxzoom = zoom;
}
sZoom = (char*)ezxml_attr(cur_node,"min-zoom");
if(sZoom) {
char *endptr;
zoom = (int)strtol(sZoom,&endptr,10);
if(*endptr != 0 || zoom < 0) {
ctx->set_error(ctx, 400, "failed to parse cache min-zoom %s (expecting a positive integer)",
sZoom);
return;
}
cachelink->minzoom = zoom;
}
sZoom = (char*)ezxml_attr(cur_node,"grids");
if(sZoom) {
char *grids = apr_pstrdup(ctx->pool,sZoom),*key,*last;
for(key = apr_strtok(grids, ",", &last); key; key = apr_strtok(NULL,",",&last)) {
/*loop through grids*/
if(!cachelink->grids) {
cachelink->grids =apr_array_make(ctx->pool,1,sizeof(char*));
}
APR_ARRAY_PUSH(cachelink->grids,char*) = key;
}
}
sZoom = (char*)ezxml_attr(cur_node,"dimensions");
if(sZoom) {
char *dims = apr_pstrdup(ctx->pool,sZoom),*key,*last;
for(key = apr_strtok(dims, ",", &last); key; key = apr_strtok(NULL,",",&last)) {
char *dimname;
/*loop through dims*/
if(!cachelink->dimensions) {
cachelink->dimensions =apr_table_make(ctx->pool,1);
}
dimname = key;
while(*key && *key!='=') key++;
if(!(*key)) {
ctx->set_error(ctx,400,"failed to parse composite cache dimensions. expecting dimensions=\"dim1=val1,dim2=val2\"");
return;
}
*key = 0;
key++;
apr_table_set(cachelink->dimensions,dimname,key);
}
}
APR_ARRAY_PUSH(cache->cache_links,mapcache_cache_composite_cache_link*) = cachelink;
}
}
/**
* \private \memberof mapcache_cache_composite
*/
static void _mapcache_cache_composite_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
}
/**
* \brief creates and initializes a mapcache_cache_composite
*/
mapcache_cache* mapcache_cache_composite_create(mapcache_context *ctx)
{
mapcache_cache_composite *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_composite));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate composite cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_COMPOSITE;
cache->cache._tile_delete = _mapcache_cache_composite_tile_delete;
cache->cache._tile_get = _mapcache_cache_composite_tile_get;
cache->cache._tile_exists = _mapcache_cache_composite_tile_exists;
cache->cache._tile_set = _mapcache_cache_composite_tile_set;
cache->cache._tile_multi_set = _mapcache_cache_composite_tile_multi_set;
cache->cache.configuration_post_config = _mapcache_cache_composite_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_composite_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
return (mapcache_cache*)cache;
}
mapcache-rel-1-14-1/lib/cache_couchbase.c 0000664 0000000 0000000 00000040623 14653160677 0020132 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: couchbase cache backend.
* Author: Michael Downey and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_COUCHBASE
#include
#include
#include
#include
typedef struct mapcache_cache_couchbase mapcache_cache_couchbase;
/**\class mapcache_cache_couchbase
* \brief a mapcache_cache on couchbase servers
* \implements mapcache_cache
*/
struct mapcache_cache_couchbase {
mapcache_cache cache;
// apr_reslist_t *connection_pool;
char *host;
char *username;
char *password;
char *bucket;
mapcache_context *ctx;
};
typedef struct getStruct
{
mapcache_buffer *tileBuffer;
libcouchbase_error_t error;
} getStruct_t;
/* Not sure if we need this. */
static void _couchbase_error_callback(libcouchbase_t instance,
libcouchbase_error_t error,
const char *errinfo)
{
/* Ignore timeouts... */
if (error != LIBCOUCHBASE_ETIMEDOUT) {
fprintf(stderr, "\nFATAL ERROR: %s\n",
libcouchbase_strerror(instance, error));
if (errinfo && strlen(errinfo) != 0) {
fprintf(stderr, "\t\"%s\"\n", errinfo);
}
}
}
static void _couchbase_get_callback(libcouchbase_t instance,
const void *cookie,
libcouchbase_error_t error,
const void *key, libcouchbase_size_t nkey,
const void *bytes, libcouchbase_size_t nbytes,
libcouchbase_uint32_t flags, libcouchbase_cas_t cas)
{
(void)instance;
(void)key;
(void)nkey;
(void)flags;
(void)cas;
if (cookie)
{
getStruct_t *request = (getStruct_t*)cookie;
request->error = error;
if (error == LIBCOUCHBASE_SUCCESS && request->tileBuffer)
{
mapcache_buffer_append(request->tileBuffer, nbytes, (void*)bytes);
}
}
}
static void _couchbase_store_callback(libcouchbase_t instance,
const void* cookie,
libcouchbase_storage_t unknown,
libcouchbase_error_t error,
const void* unknown2,
libcouchbase_size_t unknown3,
libcouchbase_cas_t cas)
{
(void)instance;
(void)unknown;
(void)unknown2;
(void)unknown3;
(void)cas;
libcouchbase_error_t* userError = (libcouchbase_error_t*)cookie;
*userError = error;
}
static apr_status_t _couchbase_reslist_get_connection(void **conn_, void *params, apr_pool_t *pool) {
mapcache_cache_couchbase *cache = (mapcache_cache_couchbase*)params;
libcouchbase_t *instance = apr_pcalloc(pool,sizeof(libcouchbase_t));
const char *host = cache->host;
const char *username = cache->username;
const char *passwd = cache->password;
const char *bucket = "default";
*instance = libcouchbase_create(host, username, passwd, bucket, NULL);
if (*instance == NULL) {
return APR_EGENERAL;
}
libcouchbase_set_error_callback(*instance, _couchbase_error_callback);
libcouchbase_set_get_callback(*instance, _couchbase_get_callback);
libcouchbase_set_storage_callback(*instance, _couchbase_store_callback);
if (libcouchbase_connect(*instance) != LIBCOUCHBASE_SUCCESS) {
return APR_EGENERAL;
}
/* Wait for the connect to compelete */
libcouchbase_wait(*instance);
*conn_ = instance;
return APR_SUCCESS;
}
static apr_status_t _couchbase_reslist_free_connection(void *conn_, void *params, apr_pool_t *pool) {
libcouchbase_t *instance = (libcouchbase_t*)conn_;
libcouchbase_destroy(*instance);
return APR_SUCCESS;
}
static libcouchbase_t* _couchbase_get_connection(mapcache_context *ctx, mapcache_tile *tile)
{
apr_status_t rv;
libcouchbase_t *instance;
mapcache_cache_couchbase *cache = (mapcache_cache_couchbase*)tile->tileset->cache;
rv = apr_reslist_acquire(cache->connection_pool, (void **)&instance);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to aquire connection to couchbase backend: %s", ctx->get_error_message(ctx));
return NULL;
}
return instance;
}
static void _couchbase_release_connection(mapcache_tile *tile, libcouchbase_t* instance)
{
mapcache_cache_couchbase* cache = (mapcache_cache_couchbase*)tile->tileset->cache;
apr_reslist_release(cache->connection_pool, (void*)instance);
}
static void _couchbase_invalidate_connection(mapcache_tile *tile, libcouchbase_t* instance)
{
mapcache_cache_couchbase* cache = (mapcache_cache_couchbase*)tile->tileset->cache;
apr_reslist_invalidate(cache->connection_pool, (void*)instance);
}
static int _mapcache_cache_couchbase_has_tile(mapcache_context *ctx, mapcache_tile *tile) {
char *key[1];
libcouchbase_t *instance;
libcouchbase_error_t error;
size_t keySize[1];
getStruct_t request;
key[0] = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
keySize[0] = strlen(key[0]);
instance = _couchbase_get_connection(ctx, tile);
request.tileBuffer = 0;
request.error = LIBCOUCHBASE_KEY_ENOENT;
error = libcouchbase_mget(*instance, &request, 1, (const void * const*)key, keySize, 0);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to get key %s: %s", key, libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FALSE;
}
libcouchbase_wait(*instance);
error = request.error;
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to get key %s: %s", key, libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FALSE;
}
_couchbase_release_connection(tile, instance);
return MAPCACHE_TRUE;
}
static void _mapcache_cache_couchbase_delete(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
libcouchbase_t *instance;
libcouchbase_error_t error;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
GC_CHECK_ERROR(ctx);
instance = _couchbase_get_connection(ctx, tile);
error = libcouchbase_remove(*instance, 0, key, strlen(key), 0);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to delete key %s: %s", key, libcouchbase_strerror(*instance, error));
}
libcouchbase_wait(*instance);
error = libcouchbase_get_last_error(*instance);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase: failed to delete key %s: %s", key, libcouchbase_strerror(*instance, error));
}
_couchbase_release_connection(tile, instance);
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the couchbase server
* \private \memberof mapcache_cache_couchbase
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_couchbase_get(mapcache_context *ctx, mapcache_tile *tile) {
char *key[1];
size_t keySize[1];
libcouchbase_t *instance;
libcouchbase_error_t error;
getStruct_t request;
key[0] = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
keySize[0] = strlen(key[0]);
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
libcouchbase_time_t expires = 86400;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
instance = _couchbase_get_connection(ctx, tile);
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
request.tileBuffer = tile->encoded_data;
error = libcouchbase_mget(*instance, &request, 1, (const void * const*)key, keySize, &expires);
if (error != LIBCOUCHBASE_SUCCESS) {
ctx->set_error(ctx, 500, "couchbase cache returned error on mget %s", libcouchbase_strerror(*instance, error));
_couchbase_invalidate_connection(tile, instance);
return MAPCACHE_FAILURE;
}
libcouchbase_wait(*instance);
if(request.error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
return MAPCACHE_CACHE_MISS;
}
if (tile->encoded_data->size == 0) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "couchbase cache returned 0-length data for tile %d %d %d", tile->x, tile->y, tile->z);
return MAPCACHE_FAILURE;
}
apr_time_t now = apr_time_now();
tile->mtime = now;
_couchbase_release_connection(tile, instance);
return MAPCACHE_SUCCESS;
}
/**
* \brief push tile data to couchbase
*
* writes the content of mapcache_tile::data to the configured couchbased instance(s)
* \private \memberof mapcache_cache_couchbase
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_couchbase_set(mapcache_context *ctx, mapcache_tile *tile) {
char *key;
libcouchbase_t *instance;
libcouchbase_error_t error;
const int max_retries = 3;
int retries = max_retries;
apr_interval_time_t delay;
/* set expiration to one day if not configured */
libcouchbase_time_t expires = 86400;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
mapcache_cache_couchbase *cache = (mapcache_cache_couchbase*)tile->tileset->cache;
key = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b", "#");
GC_CHECK_ERROR(ctx);
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
instance = _couchbase_get_connection(ctx, tile);
GC_CHECK_ERROR(ctx);
do
{
error = libcouchbase_store(*instance, &error, LIBCOUCHBASE_SET, key, strlen(key), tile->encoded_data->buf, tile->encoded_data->size, 0, expires, 0);
if (error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to eror %s.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
libcouchbase_wait(*instance);
if (error == LIBCOUCHBASE_ETMPFAIL) {
if (retries > 0) {
delay = 100000 * (1 << (max_retries - retries)); // Do an exponential back off of starting at 100 milliseconds
apr_sleep(delay);
}
else {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to %s. Maximum number of retries used.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
--retries;
}
else if (error != LIBCOUCHBASE_SUCCESS) {
_couchbase_release_connection(tile, instance);
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to couchbase cache %s due to error %s.",
tile->x, tile->y, tile->z, cache->cache.name, libcouchbase_strerror(*instance, error));
return;
}
}
while (error == LIBCOUCHBASE_ETMPFAIL);
_couchbase_release_connection(tile, instance);
}
/**
* \private \memberof mapcache_cache_couchbase
*/
static void _mapcache_cache_couchbase_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) {
ezxml_t cur_node;
apr_status_t rv;
mapcache_cache_couchbase *dcache = (mapcache_cache_couchbase*)cache;
int servercount = 0;
for(cur_node = ezxml_child(node,"server"); cur_node; cur_node = cur_node->next) {
servercount++;
}
if(!servercount) {
ctx->set_error(ctx, 400, "couchbase cache %s has no s configured", cache->name);
return;
}
if(servercount > 1) {
ctx->set_error(ctx, 400, "couchbase cache %s has more than 1 server configured", cache->name);
return;
}
cur_node = ezxml_child(node, "server");
ezxml_t xhost = ezxml_child(cur_node, "host"); /* Host should contain server:port */
ezxml_t xusername = ezxml_child(cur_node, "username");
ezxml_t xpasswd = ezxml_child(cur_node, "password");
ezxml_t xbucket = ezxml_child(cur_node, "bucket");
if(!xhost || !xhost->txt || ! *xhost->txt) {
ctx->set_error(ctx, 400, "cache %s: with no ", cache->name);
return;
} else {
dcache->host = apr_pstrdup(ctx->pool, xhost->txt);
if (dcache->host == NULL) {
ctx->set_error(ctx, 400, "cache %s: failed to allocate host string!", cache->name);
return;
}
}
if(xusername && xusername->txt && *xusername->txt) {
dcache->username = apr_pstrdup(ctx->pool, xusername->txt);
}
if(xpasswd && xpasswd->txt && *xpasswd->txt) {
dcache->password = apr_pstrdup(ctx->pool, xpasswd->txt);
}
if(xbucket && xbucket->txt && *xbucket->txt) {
dcache->bucket = apr_pstrdup(ctx->pool, xbucket->txt);
}
dcache->ctx = ctx;
rv = apr_reslist_create(&(dcache->connection_pool),
0 /* min */,
10 /* soft max */,
200 /* hard max */,
60*1000000 /*60 seconds, ttl*/,
_couchbase_reslist_get_connection, /* resource constructor */
_couchbase_reslist_free_connection, /* resource destructor */
dcache, ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to create couchbase connection pool");
return;
}
}
/**
* \private \memberof mapcache_cache_couchbase
*/
static void _mapcache_cache_couchbase_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache, mapcache_cfg *cfg) {
}
/**
* \brief creates and initializes a mapcache_couchbase_cache
*/
mapcache_cache* mapcache_cache_couchbase_create(mapcache_context *ctx) {
mapcache_cache_couchbase *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_couchbase));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate couchbase cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool, 3);
cache->cache.type = MAPCACHE_CACHE_COUCHBASE;
cache->cache.tile_get = _mapcache_cache_couchbase_get;
cache->cache.tile_exists = _mapcache_cache_couchbase_has_tile;
cache->cache.tile_set = _mapcache_cache_couchbase_set;
cache->cache.tile_delete = _mapcache_cache_couchbase_delete;
cache->cache.configuration_parse_xml = _mapcache_cache_couchbase_configuration_parse_xml;
cache->cache.configuration_post_config = _mapcache_cache_couchbase_configuration_post_config;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->host = NULL;
cache->username = NULL;
cache->password = NULL;
cache->bucket = NULL;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_couchbase_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"COUCHBASE support not compiled in this version");
return NULL;
}
#endif
/* vim: ai ts=3 sts=3 et sw=3
*/
mapcache-rel-1-14-1/lib/cache_disk.c 0000664 0000000 0000000 00000071164 14653160677 0017134 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching: filesytem cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#include
#include
#include
#include
#include
#include
#ifdef HAVE_SYMLINK
#include
#endif
/**\class mapcache_cache_disk
* \brief a mapcache_cache on a filesytem
* \implements mapcache_cache
*/
typedef struct mapcache_cache_disk mapcache_cache_disk;
struct mapcache_cache_disk {
mapcache_cache cache;
char *base_directory;
char *filename_template;
int symlink_blank;
int detect_blank;
int creation_retry;
/**
* Set filename for a given tile
* \memberof mapcache_cache_disk
*/
void (*tile_key)(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path);
};
/**
* \brief computes the relative path between two destinations
*
* \param tilename the absolute filename of the tile
* \param blankname the absolute path of the blank tile image
*/
char* relative_path(mapcache_context *ctx, char* tilename, char* blankname)
{
int updir_cnt = 0;
char *blank_rel = "";
/* work up the directory paths of the tile and blank filename to find the common
root */
char *tile_it = tilename, *blank_it = blankname;
if(*tile_it != *blank_it) {
/* the two files have no common root.
* This really shouldn't happen on a unix FS hierarchy, and symbolic linking
* is enabled only on these platforms, so this case should in practice never
* happen.
* we return the absolute path, and should probably set a warning message
*/
return apr_pstrdup(ctx->pool, blankname);
}
while(*(tile_it+1) && *(blank_it+1) && *(tile_it+1) == *(blank_it+1)) {
tile_it++;
blank_it++;
}
/* tile_it and blank_it point on the last common character of the two filenames,
which should be a '/'. If not, return the full blank name
* (and set a warning message? )*/
if(*tile_it != *blank_it || *tile_it != '/') {
return apr_pstrdup(ctx->pool, blankname);
}
blank_it++;
while(*tile_it == '/') tile_it++; /*skip leading '/'s*/
/* blank_it now contains the path that must be appended after the relative
part of the constructed path,e.g.:
- tilename = "/basepath/tilesetname/gridname/03/000/05/08.png"
- blankname = "/basepath/tilesetname/gridname/blanks/005599FF.png"
then
- tile_it is "03/000/05/08.png"
- blank_it is "blanks/005599FF.png"
*/
/* we now count the number of '/' in the remaining tilename */
while(*tile_it) {
if(*tile_it == '/') {
updir_cnt++;
/* also skip consecutive '/'s */
while(*(tile_it+1)=='/') tile_it++;
}
tile_it ++;
}
while(updir_cnt--) {
blank_rel = apr_pstrcat(ctx->pool, blank_rel, "../", NULL);
}
blank_rel = apr_pstrcat(ctx->pool,blank_rel,blank_it,NULL);
return blank_rel;
}
/**
* \brief returns base path for given tile
*
* \param tile the tile to get base path from
* \param path pointer to a char* that will contain the filename
* \private \memberof mapcache_cache_disk
*/
static void _mapcache_cache_disk_base_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path)
{
*path = apr_pstrcat(ctx->pool,
cache->base_directory,"/",
tile->tileset->name,"/",
tile->grid_link->grid->name,
NULL);
if(tile->dimensions) {
int i = tile->dimensions->nelts;
while(i--) {
mapcache_requested_dimension *entry = APR_ARRAY_IDX(tile->dimensions,i,mapcache_requested_dimension*);
char *dimval;
if(!entry->cached_value) {
ctx->set_error(ctx,500,"BUG: dimension (%s) not set",entry->dimension->name);
return;
}
dimval = mapcache_util_str_sanitize(ctx->pool,entry->cached_value,"/.",'#');
*path = apr_pstrcat(ctx->pool,*path,"/",dimval,NULL);
}
}
}
static void _mapcache_cache_disk_blank_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, unsigned char *color, char **path)
{
/* not implemented for template caches, as symlink_blank will never be set */
*path = apr_psprintf(ctx->pool,"%s/%s/%s/blanks/%02X%02X%02X%02X.%s",
cache->base_directory,
tile->tileset->name,
tile->grid_link->grid->name,
color[0],
color[1],
color[2],
color[3],
tile->tileset->format?tile->tileset->format->extension:"png");
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate blank tile key");
}
}
/**
* \brief return filename for given tile
*
* \param tile the tile to get the key from
* \param path pointer to a char* that will contain the filename
* \param r
* \private \memberof mapcache_cache_disk
*/
static void _mapcache_cache_disk_tilecache_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path)
{
if(cache->base_directory) {
char *start;
_mapcache_cache_disk_base_tile_key(ctx, cache, tile, &start);
*path = apr_psprintf(ctx->pool,"%s/%02d/%03d/%03d/%03d/%03d/%03d/%03d.%s",
start,
tile->z,
tile->x / 1000000,
(tile->x / 1000) % 1000,
tile->x % 1000,
tile->y / 1000000,
(tile->y / 1000) % 1000,
tile->y % 1000,
tile->tileset->format?tile->tileset->format->extension:"png");
} else {
*path = cache->filename_template;
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{tileset}", tile->tileset->name);
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{grid}", tile->grid_link->grid->name);
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{ext}",
tile->tileset->format?tile->tileset->format->extension:"png");
if(strstr(*path,"{x}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{x}",
apr_psprintf(ctx->pool,"%d",tile->x));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_x}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1));
if(strstr(*path,"{y}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{y}",
apr_psprintf(ctx->pool,"%d",tile->y));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_y}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1));
if(strstr(*path,"{z}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{z}",
apr_psprintf(ctx->pool,"%d",tile->z));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_z}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->nlevels - tile->z - 1));
if(tile->dimensions && strstr(*path,"{dim")) {
char *dimstring="";
int i = tile->dimensions->nelts;
while(i--) {
mapcache_requested_dimension *entry = APR_ARRAY_IDX(tile->dimensions,i, mapcache_requested_dimension*);
char *dimval;
char *single_dim;
char *iter;
if(!entry->cached_value) {
ctx->set_error(ctx,500,"BUG: dimension (%s) not set",entry->dimension->name);
return;
}
dimval = apr_pstrdup(ctx->pool,entry->cached_value);
iter = dimval;
while(*iter) {
/* replace dangerous characters by '#' */
if(*iter == '.' || *iter == '/') {
*iter = '#';
}
iter++;
}
dimstring = apr_pstrcat(ctx->pool,dimstring,"#",entry->dimension->name,"#",dimval,NULL);
single_dim = apr_pstrcat(ctx->pool,"{dim:",entry->dimension->name,"}",NULL);
if(strstr(*path,single_dim)) {
*path = mapcache_util_str_replace_all(ctx->pool,*path, single_dim, dimval);
}
}
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{dim}", dimstring);
}
}
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
static void _mapcache_cache_disk_template_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path)
{
*path = cache->filename_template;
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{tileset}", tile->tileset->name);
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{grid}", tile->grid_link->grid->name);
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{ext}",
tile->tileset->format?tile->tileset->format->extension:"png");
if(strstr(*path,"{x}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{x}",
apr_psprintf(ctx->pool,"%d",tile->x));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_x}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1));
if(strstr(*path,"{y}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{y}",
apr_psprintf(ctx->pool,"%d",tile->y));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_y}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1));
if(strstr(*path,"{z}"))
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{z}",
apr_psprintf(ctx->pool,"%d",tile->z));
else
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{inv_z}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->nlevels - tile->z - 1));
if(tile->dimensions && strstr(*path,"{dim")) {
char *dimstring="";
int i = tile->dimensions->nelts;
while(i--) {
mapcache_requested_dimension *entry = APR_ARRAY_IDX(tile->dimensions,i, mapcache_requested_dimension*);
char *dimval;
char *single_dim;
char *iter;
if(!entry->cached_value) {
ctx->set_error(ctx,500,"BUG: dimension (%s) not set",entry->dimension->name);
return;
}
dimval = apr_pstrdup(ctx->pool,entry->cached_value);
iter = dimval;
while(*iter) {
/* replace dangerous characters by '#' */
if(*iter == '.' || *iter == '/') {
*iter = '#';
}
iter++;
}
dimstring = apr_pstrcat(ctx->pool,dimstring,"#",entry->dimension->name,"#",dimval,NULL);
single_dim = apr_pstrcat(ctx->pool,"{dim:",entry->dimension->name,"}",NULL);
if(strstr(*path,single_dim)) {
*path = mapcache_util_str_replace_all(ctx->pool,*path, single_dim, dimval);
}
}
*path = mapcache_util_str_replace_all(ctx->pool,*path, "{dim}", dimstring);
}
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
static void _mapcache_cache_disk_arcgis_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path)
{
if(cache->base_directory) {
char *start;
_mapcache_cache_disk_base_tile_key(ctx, cache, tile, &start);
*path = apr_psprintf(ctx->pool,"%s/L%02d/R%08x/C%08x.%s" ,
start,
tile->z,
tile->y,
tile->x,
tile->tileset->format?tile->tileset->format->extension:"png");
}
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
static void _mapcache_cache_disk_worldwind_tile_key(mapcache_context *ctx, mapcache_cache_disk *cache, mapcache_tile *tile, char **path)
{
if(cache->base_directory) {
*path = apr_psprintf(ctx->pool,"%s/%d/%04d/%04d_%04d.%s" ,
cache->base_directory,
tile->z,
tile->y,
tile->y,
tile->x,
tile->tileset->format?tile->tileset->format->extension:"png");
}
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
static int _mapcache_cache_disk_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *filename;
apr_finfo_t finfo;
int rv;
mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache;
cache->tile_key(ctx, cache, tile, &filename);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
rv = apr_stat(&finfo,filename,0,ctx->pool);
if(rv != APR_SUCCESS) {
return MAPCACHE_FALSE;
} else {
return MAPCACHE_TRUE;
}
}
static void _mapcache_cache_disk_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
apr_status_t ret;
char errmsg[120];
char *filename;
mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache;
cache->tile_key(ctx, cache, tile, &filename);
GC_CHECK_ERROR(ctx);
ret = apr_file_remove(filename,ctx->pool);
if(ret != APR_SUCCESS && !APR_STATUS_IS_ENOENT(ret)) {
ctx->set_error(ctx, 500, "failed to remove file %s: %s",filename, apr_strerror(ret,errmsg,120));
}
}
/**
* \brief get file content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored in the file
* \private \memberof mapcache_cache_disk
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_disk_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *filename;
apr_file_t *f;
apr_finfo_t finfo;
apr_status_t rv;
apr_size_t size;
apr_mmap_t *tilemmap;
mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache;
cache->tile_key(ctx, cache, tile, &filename);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
ctx->log(ctx,MAPCACHE_DEBUG,"checking for tile %s",filename);
if((rv=apr_file_open(&f, filename,
#ifndef NOMMAP
APR_FOPEN_READ, APR_UREAD | APR_GREAD,
#else
APR_FOPEN_READ|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,APR_OS_DEFAULT,
#endif
ctx->pool)) == APR_SUCCESS) {
rv = apr_file_info_get(&finfo, APR_FINFO_SIZE|APR_FINFO_MTIME, f);
if(!finfo.size) {
ctx->log(ctx, MAPCACHE_WARN, "tile %s has 0 length data",filename);
return MAPCACHE_CACHE_MISS;
}
size = finfo.size;
/*
* at this stage, we have a handle to an open file that contains data.
* idealy, we should acquire a read lock, in case the data contained inside the file
* is incomplete (i.e. if another process is currently writing to the tile).
* currently such a lock is not set, as we don't want to lose performance on tile accesses.
* any error that might happen at this stage should only occur if the tile isn't already cached,
* i.e. normally only once.
*/
tile->mtime = finfo.mtime;
#ifndef NOMMAP
tile->encoded_data = mapcache_buffer_create(0,ctx->pool);
rv = apr_mmap_create(&tilemmap,f,0,finfo.size,APR_MMAP_READ,ctx->pool);
if(rv != APR_SUCCESS) {
char errmsg[120];
ctx->set_error(ctx, 500, "mmap error: %s",apr_strerror(rv,errmsg,120));
return MAPCACHE_FAILURE;
}
tile->encoded_data->buf = tilemmap->mm;
tile->encoded_data->size = tile->encoded_data->avail = finfo.size;
#else
tile->encoded_data = mapcache_buffer_create(size,ctx->pool);
//manually add the data to our buffer
apr_file_read(f,(void*)tile->encoded_data->buf,&size);
tile->encoded_data->size = size;
tile->encoded_data->avail = size;
#endif
apr_file_close(f);
if(tile->encoded_data->size != finfo.size) {
ctx->set_error(ctx, 500, "failed to copy image data, got %d of %d bytes",(int)size, (int)finfo.size);
return MAPCACHE_FAILURE;
}
return MAPCACHE_SUCCESS;
} else {
if(APR_STATUS_IS_ENOENT(rv)) {
/* the file doesn't exist on the disk */
return MAPCACHE_CACHE_MISS;
} else {
char *error = strerror(rv);
ctx->set_error(ctx, 500, "failed to open file %s: %s",filename, error);
return MAPCACHE_FAILURE;
}
}
}
/**
* \brief write tile data to disk
*
* writes the content of mapcache_tile::data to disk.
* \returns MAPCACHE_FAILURE if there is no data to write, or if the tile isn't locked
* \returns MAPCACHE_SUCCESS if the tile has been successfully written to disk
* \private \memberof mapcache_cache_disk
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
apr_size_t bytes;
apr_file_t *f;
apr_status_t ret;
char errmsg[120];
char *filename;
mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache;
const int creation_retry = cache->creation_retry;
int retry_count_create_file = 0;
#ifdef DEBUG
/* all this should be checked at a higher level */
if(!tile->encoded_data && !tile->raw_image) {
ctx->set_error(ctx,500,"attempting to write empty tile to disk");
return;
}
if(!tile->encoded_data && !tile->tileset->format) {
ctx->set_error(ctx,500,"received a raw tile image for a tileset with no format");
return;
}
#endif
cache->tile_key(ctx, cache, tile, &filename);
GC_CHECK_ERROR(ctx);
if ( cache->detect_blank ) {
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
if(tile->raw_image->data[3] == 0) {
/* We have a blank (uniform) image who's first pixel is fully transparent, thus the whole image is transparent */
#ifdef DEBUG
ctx->log(ctx, MAPCACHE_DEBUG, "skipped blank tile %s",filename);
#endif
tile->nodata = 1;
return;
}
}
}
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)) {
ctx->set_error(ctx, 500, "failed to remove file %s: %s",filename, apr_strerror(ret,errmsg,120));
}
#ifdef HAVE_SYMLINK
if ( cache->symlink_blank
&& (!tile->tileset->format || tile->tileset->format->type != GC_RAW) )
{
// is handled when tileset's format, if set, is not RAW
if (!tile->raw_image)
{
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
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);
}
mapcache_make_parent_dirs(ctx,blankname);
GC_CHECK_ERROR(ctx);
/* acquire a lock on the blank file */
isLocked = mapcache_lock_or_wait_for_resource(ctx,ctx->config->locker,blankname, &lock);
if(isLocked == MAPCACHE_TRUE) {
if((ret = apr_file_open(&f, blankname,
APR_FOPEN_CREATE|APR_FOPEN_WRITE|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,
APR_OS_DEFAULT, ctx->pool)) != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to create file %s: %s",blankname, apr_strerror(ret,errmsg,120));
mapcache_unlock_resource(ctx,ctx->config->locker, lock);
return; /* we could not create the file */
}
bytes = (apr_size_t)tile->encoded_data->size;
ret = apr_file_write(f,(void*)tile->encoded_data->buf,&bytes);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to write data to file %s (wrote %d of %d bytes): %s",blankname, (int)bytes, (int)tile->encoded_data->size, apr_strerror(ret,errmsg,120));
mapcache_unlock_resource(ctx,ctx->config->locker, lock);
return; /* we could not create the file */
}
if(bytes != tile->encoded_data->size) {
ctx->set_error(ctx, 500, "failed to write image data to %s, wrote %d of %d bytes", blankname, (int)bytes, (int)tile->encoded_data->size);
mapcache_unlock_resource(ctx,ctx->config->locker, lock);
return;
}
apr_file_close(f);
mapcache_unlock_resource(ctx,ctx->config->locker, lock);
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"created blank tile %s",blankname);
#endif
}
} else {
apr_file_close(f);
}
/*
* compute the relative path between tile and blank tile
*/
blankname_rel = relative_path(ctx,filename, blankname);
GC_CHECK_ERROR(ctx);
/*
* depending on configuration symlink creation will retry if it fails.
* this can happen on nfs mounted network storage.
* the solution is to create the containing directory again and retry the symlink creation.
*/
while(symlink(blankname_rel, filename) != 0) {
retry_count_create_symlink++;
if(retry_count_create_symlink > creation_retry) {
char *error = strerror(errno);
ctx->set_error(ctx, 500, "failed to link tile %s to %s: %s",filename, blankname_rel, error);
return; /* we could not create the file */
}
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);
#endif
return;
}
}
#endif /* HAVE_SYMLINK */
/* go the normal way: either we haven't configured blank tile detection, or the tile was not blank */
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
bytes = (apr_size_t)tile->encoded_data->size;
if(bytes == 0) {
ctx->set_error(ctx, 500, "attempting to write 0 length tile to %s",filename);
return; /* we could not create the file */
}
/*
* depending on configuration file creation will retry if it fails.
* this can happen on nfs mounted network storage.
* the solution is to create the containing directory again and retry the file creation.
*/
while((ret = apr_file_open(&f, filename,
APR_FOPEN_CREATE|APR_FOPEN_WRITE|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,
APR_OS_DEFAULT, ctx->pool)) != APR_SUCCESS) {
retry_count_create_file++;
if(retry_count_create_file > creation_retry) {
ctx->set_error(ctx, 500, "failed to create file %s: %s",filename, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
mapcache_make_parent_dirs(ctx,filename);
GC_CHECK_ERROR(ctx);
}
ret = apr_file_write(f,(void*)tile->encoded_data->buf,&bytes);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to write data to file %s (wrote %d of %d bytes): %s",filename, (int)bytes, (int)tile->encoded_data->size, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
ret = apr_file_close(f);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to close file %s:%s",filename, apr_strerror(ret,errmsg,120));
}
if(bytes != tile->encoded_data->size) {
ctx->set_error(ctx, 500, "failed to write image data to %s, wrote %d of %d bytes", filename, (int)bytes, (int)tile->encoded_data->size);
apr_file_remove(filename, ctx->pool);
}
}
/**
* \private \memberof mapcache_cache_disk
*/
static void _mapcache_cache_disk_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_disk *dcache = (mapcache_cache_disk*)cache;
char *layout = NULL;
int template_layout = MAPCACHE_FALSE;
layout = (char*)ezxml_attr(node,"layout");
if (!layout || !strlen(layout) || !strcmp(layout,"tilecache")) {
dcache->tile_key = _mapcache_cache_disk_tilecache_tile_key;
} else if(!strcmp(layout,"arcgis")) {
dcache->tile_key = _mapcache_cache_disk_arcgis_tile_key;
} else if(!strcmp(layout,"worldwind")) {
dcache->tile_key = _mapcache_cache_disk_worldwind_tile_key;
} else if (!strcmp(layout,"template")) {
dcache->tile_key = _mapcache_cache_disk_template_tile_key;
template_layout = MAPCACHE_TRUE;
if ((cur_node = ezxml_child(node,"template")) != NULL) {
dcache->filename_template = apr_pstrdup(ctx->pool,cur_node->txt);
} else {
ctx->set_error(ctx, 400, "no template specified for cache \"%s\"", cache->name);
return;
}
} else {
ctx->set_error(ctx, 400, "unknown layout type %s for cache \"%s\"", layout, cache->name);
return;
}
if (!template_layout && (cur_node = ezxml_child(node,"base")) != NULL) {
dcache->base_directory = apr_pstrdup(ctx->pool,cur_node->txt);
}
if (!template_layout && (cur_node = ezxml_child(node,"symlink_blank")) != NULL) {
if(strcasecmp(cur_node->txt,"false")) {
#ifdef HAVE_SYMLINK
dcache->symlink_blank=1;
#else
ctx->set_error(ctx,400,"cache %s: host system does not support file symbolic linking",cache->name);
return;
#endif
}
}
if ((cur_node = ezxml_child(node,"creation_retry")) != NULL) {
dcache->creation_retry = atoi(cur_node->txt);
}
if ((cur_node = ezxml_child(node,"detect_blank")) != NULL) {
dcache->detect_blank=1;
}
}
/**
* \private \memberof mapcache_cache_disk
*/
static void _mapcache_cache_disk_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
mapcache_cache_disk *dcache = (mapcache_cache_disk*)cache;
/* check all required parameters are configured */
if((!dcache->base_directory || !strlen(dcache->base_directory)) &&
(!dcache->filename_template || !strlen(dcache->filename_template))) {
ctx->set_error(ctx, 400, "disk cache %s has no base directory or template",dcache->cache.name);
return;
}
}
/**
* \brief creates and initializes a mapcache_disk_cache
*/
mapcache_cache* mapcache_cache_disk_create(mapcache_context *ctx)
{
mapcache_cache_disk *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_disk));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate disk cache");
return NULL;
}
cache->symlink_blank = 0;
cache->detect_blank = 0;
cache->creation_retry = 0;
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_DISK;
cache->cache._tile_delete = _mapcache_cache_disk_delete;
cache->cache._tile_get = _mapcache_cache_disk_get;
cache->cache._tile_exists = _mapcache_cache_disk_has_tile;
cache->cache._tile_set = _mapcache_cache_disk_set;
cache->cache.configuration_post_config = _mapcache_cache_disk_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_disk_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
return (mapcache_cache*)cache;
}
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_fallback.c 0000664 0000000 0000000 00000020366 14653160677 0017737 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapServer
* Purpose: MapCache tile caching: fallback cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without fallbackriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
typedef struct mapcache_cache_fallback mapcache_cache_fallback;
struct mapcache_cache_fallback {
mapcache_cache cache;
apr_array_header_t *caches;
};
static int _mapcache_cache_fallback_tile_exists(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,0,mapcache_cache*);
return mapcache_cache_tile_exists(ctx, subcache, tile);
}
static void _mapcache_cache_fallback_tile_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
int i;
for(i=0; icaches->nelts; i++) {
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
mapcache_cache_tile_delete(ctx, subcache, tile);
ctx->clear_errors(ctx); /* ignore errors */
}
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the fallback server
* \private \memberof mapcache_cache_fallback
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_fallback_tile_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
mapcache_cache *subcache;
int i,ret;
subcache = APR_ARRAY_IDX(cache->caches,0,mapcache_cache*);
ret = mapcache_cache_tile_get(ctx, subcache, tile);
if(ret == MAPCACHE_FAILURE) {
int first_error = ctx->get_error(ctx);
char *first_error_message = ctx->get_error_message(ctx);
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; icaches->nelts; i++) {
subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
if((ret = mapcache_cache_tile_get(ctx, subcache, tile)) == MAPCACHE_FAILURE) {
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;
} else {
return ret;
}
}
/* all backends failed, return primary error message */
ctx->set_error(ctx,first_error,"%s",first_error_message);
return MAPCACHE_FAILURE;
} else {
/* success or notfound */
return ret;
}
}
static void _mapcache_cache_fallback_tile_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
int i,first_error=0;
char *first_error_message;
for(i=0; icaches->nelts; i++) {
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
mapcache_cache_tile_set(ctx, subcache, tile);
if(GC_HAS_ERROR(ctx)) {
if(!first_error) {
first_error = ctx->get_error(ctx);
first_error_message = ctx->get_error_message(ctx);
}
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);
}
}
if(first_error) {
ctx->set_error(ctx,first_error,"%s",first_error_message);
}
}
static void _mapcache_cache_fallback_tile_multi_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
int i,first_error=0;
char *first_error_message;
for(i=0; icaches->nelts; i++) {
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
mapcache_cache_tile_multi_set(ctx, subcache, tiles, ntiles);
if(GC_HAS_ERROR(ctx)) {
if(!first_error) {
first_error = ctx->get_error(ctx);
first_error_message = ctx->get_error_message(ctx);
}
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);
}
}
if(first_error) {
ctx->set_error(ctx,first_error,"%s",first_error_message);
}
}
/**
* \private \memberof mapcache_cache_fallback
*/
static void _mapcache_cache_fallback_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *pcache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_fallback *cache = (mapcache_cache_fallback*)pcache;
cache->caches = apr_array_make(ctx->pool,3,sizeof(mapcache_cache*));
for(cur_node = ezxml_child(node,"cache"); cur_node; cur_node = cur_node->next) {
mapcache_cache *refcache = mapcache_configuration_get_cache(config, cur_node->txt);
if(!refcache) {
ctx->set_error(ctx, 400, "fallback cache \"%s\" references cache \"%s\","
" but it is not configured (hint:referenced caches must be declared before this fallback cache in the xml file)", pcache->name, cur_node->txt);
return;
}
APR_ARRAY_PUSH(cache->caches,mapcache_cache*) = refcache;
}
if(cache->caches->nelts == 0) {
ctx->set_error(ctx,400,"fallback cache \"%s\" does not reference any child caches", pcache->name);
}
}
/**
* \private \memberof mapcache_cache_fallback
*/
static void _mapcache_cache_fallback_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
}
/**
* \brief creates and initializes a mapcache_cache_fallback
*/
mapcache_cache* mapcache_cache_fallback_create(mapcache_context *ctx)
{
mapcache_cache_fallback *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_fallback));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate fallback cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_COMPOSITE;
cache->cache._tile_delete = _mapcache_cache_fallback_tile_delete;
cache->cache._tile_get = _mapcache_cache_fallback_tile_get;
cache->cache._tile_exists = _mapcache_cache_fallback_tile_exists;
cache->cache._tile_set = _mapcache_cache_fallback_tile_set;
cache->cache._tile_multi_set = _mapcache_cache_fallback_tile_multi_set;
cache->cache.configuration_post_config = _mapcache_cache_fallback_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_fallback_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
return (mapcache_cache*)cache;
}
mapcache-rel-1-14-1/lib/cache_lmdb.c 0000664 0000000 0000000 00000040040 14653160677 0017105 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapCache
* Purpose: MapCache tile caching support file: LMDB cache backend
* Author: Maris Nartiss and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2022 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_LMDB
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef _WIN32
#include
#endif
#include "lmdb.h"
typedef struct mapcache_cache_lmdb mapcache_cache_lmdb;
struct mapcache_cache_lmdb {
mapcache_cache cache;
char *basedir;
char *key_template;
size_t max_size;
unsigned int max_readers;
MDB_env *env;
};
/* LMDB env should be opened only once per process */
typedef struct lmdb_env_s lmdb_env_s;
struct lmdb_env_s {
MDB_env *env;
MDB_dbi dbi;
int is_open;
};
static lmdb_env_s *lmdb_env;
static int _mapcache_cache_lmdb_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
int rc, ret;
MDB_val key, data;
MDB_txn *txn;
mapcache_cache_lmdb *cache = (mapcache_cache_lmdb*)pcache;
char *skey;
if (lmdb_env->is_open == 0) {
ctx->set_error(ctx,500,"lmdb is not open %s",cache->basedir);
return MAPCACHE_FALSE;
}
skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
key.mv_size = strlen(skey)+1;
key.mv_data = skey;
rc = mdb_txn_begin(lmdb_env->env, NULL, MDB_RDONLY, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction for has_tile in %s:%s",cache->basedir,mdb_strerror(rc));
return MAPCACHE_FALSE;
}
rc = mdb_get(txn, lmdb_env->dbi, &key, &data);
if(rc == 0) {
ret = MAPCACHE_TRUE;
} else if(rc == MDB_NOTFOUND) {
ret = MAPCACHE_FALSE;
} else {
ctx->set_error(ctx,500,"lmdb failed to get tile for has_tile in %s:%s",cache->basedir,mdb_strerror(rc));
ret = MAPCACHE_FALSE;
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction for has_tile in %s:%s",cache->basedir,mdb_strerror(rc));
ret = MAPCACHE_FALSE;
}
return ret;
}
static void _mapcache_cache_lmdb_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
int rc;
MDB_val key;
MDB_txn *txn;
mapcache_cache_lmdb *cache = (mapcache_cache_lmdb*)pcache;
char *skey;
if (lmdb_env->is_open == 0) {
ctx->set_error(ctx,500,"lmdb is not open %s",cache->basedir);
return;
}
skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
key.mv_size = strlen(skey)+1;
key.mv_data = skey;
rc = mdb_txn_begin(lmdb_env->env, NULL, 0, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction for delete in %s:%s",cache->basedir,mdb_strerror(rc));
return;
}
rc = mdb_del(txn, lmdb_env->dbi, &key, NULL);
if (rc) {
if (rc == MDB_NOTFOUND) {
ctx->log(ctx,MAPCACHE_DEBUG,"attempt to delete tile %s absent in the db %s",skey,cache->basedir);
}
else {
ctx->set_error(ctx,500,"lmdb failed to delete for tile_delete in %s:%s",cache->basedir,mdb_strerror(rc));
}
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction for delete in %s:%s",cache->basedir,mdb_strerror(rc));
}
}
static int _mapcache_cache_lmdb_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
int rc, ret;
MDB_val key, data;
MDB_txn *txn;
char *skey;
mapcache_cache_lmdb *cache = (mapcache_cache_lmdb*)pcache;
if (lmdb_env->is_open == 0) {
ctx->set_error(ctx,500,"lmdb is not open %s",cache->basedir);
return MAPCACHE_FALSE;
}
skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
key.mv_size = strlen(skey)+1;
key.mv_data = skey;
rc = mdb_txn_begin(lmdb_env->env, NULL, MDB_RDONLY, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction for get in %s:%s",cache->basedir,mdb_strerror(rc));
return MAPCACHE_FALSE;
}
rc = mdb_get(txn, lmdb_env->dbi, &key, &data);
if(rc == 0) {
if(((char*)(data.mv_data))[0] == '#') {
tile->encoded_data = mapcache_empty_png_decode(ctx,tile->grid_link->grid->tile_sx, tile->grid_link->grid->tile_sy, (unsigned char*)data.mv_data,&tile->nodata);
} else {
tile->encoded_data = mapcache_buffer_create(data.mv_size,ctx->pool);
memcpy(tile->encoded_data->buf, data.mv_data, data.mv_size);
tile->encoded_data->size = data.mv_size-sizeof(apr_time_t);
tile->encoded_data->avail = data.mv_size;
}
tile->mtime = *((apr_time_t*)(((char*)data.mv_data)+data.mv_size-sizeof(apr_time_t)));
ret = MAPCACHE_SUCCESS;
} else if(rc == MDB_NOTFOUND) {
ret = MAPCACHE_CACHE_MISS;
} else {
ctx->set_error(ctx,500,"lmdb failed for tile_get in %s:%s",cache->basedir,mdb_strerror(rc));
ret = MAPCACHE_FAILURE;
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction for tile_get in %s:%s",cache->basedir,mdb_strerror(rc));
ret = MAPCACHE_FALSE;
}
return ret;
}
static void _mapcache_cache_lmdb_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
int rc;
MDB_val key, data;
MDB_txn *txn;
apr_time_t now;
mapcache_cache_lmdb *cache = (mapcache_cache_lmdb*)pcache;
char *skey = mapcache_util_get_tile_key(ctx,tile,cache->key_template,NULL,NULL);
now = apr_time_now();
key.mv_size = strlen(skey)+1;
key.mv_data = skey;
if(!tile->raw_image) {
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.mv_size = 5+sizeof(apr_time_t);
data.mv_data = apr_palloc(ctx->pool,data.mv_size);
(((char*)data.mv_data)[0])='#';
memcpy(((char*)data.mv_data)+1,tile->raw_image->data,4);
memcpy(((char*)data.mv_data)+5,&now,sizeof(apr_time_t));
} else {
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
data.mv_data = tile->encoded_data->buf;
data.mv_size = tile->encoded_data->size;
tile->encoded_data->size -= sizeof(apr_time_t);
}
if (lmdb_env->is_open == 0) {
ctx->set_error(ctx,500,"lmdb is not open %s",cache->basedir);
return;
}
rc = mdb_txn_begin(lmdb_env->env, NULL, 0, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction for set in %s:%s",cache->basedir,mdb_strerror(rc));
return;
}
rc = mdb_put(txn, lmdb_env->dbi, &key, &data, 0);
if(rc) {
ctx->set_error(ctx,500,"lmbd failed to put for tile_set in %s:%s",cache->basedir,mdb_strerror(rc));
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction for tile_set in %s:%s",cache->basedir,mdb_strerror(rc));
}
}
static void _mapcache_cache_lmdb_multiset(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
int rc;
MDB_val key, data;
MDB_txn *txn;
int i;
apr_time_t now;
mapcache_cache_lmdb *cache = (mapcache_cache_lmdb*)pcache;
now = apr_time_now();
if (lmdb_env->is_open == 0) {
ctx->set_error(ctx,500,"lmdb is not open %s",cache->basedir);
return;
}
rc = mdb_txn_begin(lmdb_env->env, NULL, 0, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction for multiset in %s:%s",cache->basedir,mdb_strerror(rc));
return;
}
for(i=0; ikey_template,NULL,NULL);
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
if(GC_HAS_ERROR(ctx)) {
goto abort_txn;
}
}
if(tile->raw_image->h==256 && tile->raw_image->w==256 && mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
data.mv_size = 5+sizeof(apr_time_t);
data.mv_data = apr_palloc(ctx->pool,data.mv_size);
(((char*)data.mv_data)[0])='#';
memcpy(((char*)data.mv_data)+1,tile->raw_image->data,4);
memcpy(((char*)data.mv_data)+5,&now,sizeof(apr_time_t));
} else {
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
if(GC_HAS_ERROR(ctx)) {
goto abort_txn;
}
}
mapcache_buffer_append(tile->encoded_data,sizeof(apr_time_t),&now);
data.mv_data = tile->encoded_data->buf;
data.mv_size = tile->encoded_data->size;
tile->encoded_data->size -= sizeof(apr_time_t);
}
key.mv_data = skey;
key.mv_size = strlen(skey)+1;
rc = mdb_put(txn, lmdb_env->dbi, &key, &data, 0);
if(rc) {
ctx->set_error(ctx,500,"lmbd failed to put for multiset in %s:%s",cache->basedir,mdb_strerror(rc));
goto abort_txn;
}
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction for multiset in %s:%s",cache->basedir,mdb_strerror(rc));
}
return;
abort_txn:
mdb_txn_abort(txn);
}
static void _mapcache_cache_lmdb_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_lmdb *dcache = (mapcache_cache_lmdb*)cache;
int max_size;
apr_status_t rv;
if ((cur_node = ezxml_child(node,"base")) != NULL) {
dcache->basedir = apr_pstrdup(ctx->pool,cur_node->txt);
}
if ((cur_node = ezxml_child(node,"key_template")) != NULL) {
dcache->key_template = apr_pstrdup(ctx->pool,cur_node->txt);
} else {
dcache->key_template = apr_pstrdup(ctx->pool,"{tileset}-{grid}-{dim}-{z}-{y}-{x}.{ext}");
}
if ((cur_node = ezxml_child(node,"max_size")) != NULL) {
rv = apr_cstr_atoi(&max_size,cur_node->txt);
if(rv != APR_SUCCESS) {
char errmsg[120];
ctx->set_error(ctx,500,"lmdb cache failed to parse max_size %s:%s",cur_node->txt,apr_strerror(rv,errmsg,120));
return;
}
} else {
max_size = 64; /* = 250MiB on most systems */
}
dcache->max_size = sysconf(_SC_PAGESIZE) * max_size * 1000;
/* Max_readers defaults to 126 */
if ((cur_node = ezxml_child(node,"max_readers")) != NULL) {
unsigned int max_readers;
rv = apr_cstr_atoui(&max_readers,cur_node->txt);
if(rv != APR_SUCCESS) {
char errmsg[120];
ctx->set_error(ctx,500,"lmdb cache failed to parse max_readers %s:%s",cur_node->txt,apr_strerror(rv,errmsg,120));
return;
}
dcache->max_readers = max_readers;
}
if(!dcache->basedir) {
ctx->set_error(ctx,500,"lmbd cache \"%s\" is missing entry",cache->name);
return;
}
}
/**
* \private \memberof mapcache_cache_lmdb
*/
static void _mapcache_cache_lmdb_configuration_post_config(mapcache_context *ctx,
mapcache_cache *cache, mapcache_cfg *cfg)
{
mapcache_cache_lmdb *dcache = (mapcache_cache_lmdb*)cache;
apr_status_t rv;
apr_dir_t *dir;
rv = apr_dir_open(&dir, dcache->basedir, ctx->pool);
if(rv != APR_SUCCESS) {
char errmsg[120];
ctx->set_error(ctx,500,"lmdb failed to open directory %s:%s",dcache->basedir,apr_strerror(rv,errmsg,120));
return;
}
}
static void _mapcache_cache_lmdb_child_init(mapcache_context *ctx, mapcache_cache *cache, apr_pool_t *pchild)
{
mapcache_cache_lmdb *dcache = (mapcache_cache_lmdb*)cache;
int rc, dead=0;
MDB_txn *txn;
lmdb_env_s *var = apr_pcalloc(ctx->pool,sizeof(lmdb_env_s));
lmdb_env = var;
lmdb_env->is_open = 0;
rc = mdb_env_create(&(lmdb_env->env));
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to create environment of database %s:%s",dcache->basedir,mdb_strerror(rc));
return;
}
rc = mdb_env_set_mapsize(lmdb_env->env, dcache->max_size);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to set maximum size of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_env_close(lmdb_env->env);
return;
}
if (dcache->max_readers) {
rc = mdb_env_set_maxreaders(lmdb_env->env, dcache->max_readers);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to set maximum readers of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_env_close(lmdb_env->env);
return;
}
}
/* Clean out any stale reader entries from lock table */
rc = mdb_reader_check(lmdb_env->env, &dead);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to clear stale readers of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_env_close(lmdb_env->env);
return;
}
if (dead) {
ctx->log(ctx,MAPCACHE_NOTICE,"lmdb cleared %d stale readers of database %s",dead,dcache->basedir);
}
rc = mdb_env_open(lmdb_env->env, dcache->basedir, 0, 0664);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to open environment of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_env_close(lmdb_env->env);
return;
}
rc = mdb_txn_begin(lmdb_env->env, NULL, MDB_CREATE, &txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to begin transaction of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_env_close(lmdb_env->env);
return;
}
rc = mdb_dbi_open(txn, NULL, 0, &(lmdb_env->dbi));
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to open dbi of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_txn_abort(txn);
mdb_env_close(lmdb_env->env);
return;
}
rc = mdb_txn_commit(txn);
if (rc) {
ctx->set_error(ctx,500,"lmdb failed to commit transaction of database %s:%s",dcache->basedir,mdb_strerror(rc));
mdb_dbi_close(lmdb_env->env, lmdb_env->dbi);
mdb_env_close(lmdb_env->env);
return;
}
lmdb_env->is_open = 1;
}
/**
* \brief creates and initializes a mapcache_dbd_cache
*/
mapcache_cache* mapcache_cache_lmdb_create(mapcache_context *ctx)
{
mapcache_cache_lmdb *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_lmdb));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate LMDB cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_LMDB;
cache->cache._tile_delete = _mapcache_cache_lmdb_delete;
cache->cache._tile_get = _mapcache_cache_lmdb_get;
cache->cache._tile_exists = _mapcache_cache_lmdb_has_tile;
cache->cache._tile_set = _mapcache_cache_lmdb_set;
cache->cache._tile_multi_set = _mapcache_cache_lmdb_multiset;
cache->cache.configuration_post_config = _mapcache_cache_lmdb_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_lmdb_configuration_parse_xml;
cache->cache.child_init = _mapcache_cache_lmdb_child_init;
cache->basedir = NULL;
cache->key_template = NULL;
cache->max_readers = 0;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_lmdb_create(mapcache_context *ctx)
{
ctx->set_error(ctx,400,"LMDB support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_memcache.c 0000664 0000000 0000000 00000032460 14653160677 0017740 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: memcache cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_MEMCACHE
#include
typedef struct mapcache_cache_memcache mapcache_cache_memcache;
/**\class mapcache_cache_memcache
* \brief a mapcache_cache on memcached servers
* \implements mapcache_cache
*/
struct mapcache_cache_memcache_server {
char* host;
int port;
};
struct mapcache_cache_memcache {
mapcache_cache cache;
int nservers;
struct mapcache_cache_memcache_server *servers;
int detect_blank;
};
struct mapcache_memcache_conn_param {
mapcache_cache_memcache *cache;
};
struct mapcache_memcache_pooled_connection {
apr_memcache_t *memcache;
apr_pool_t *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,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;
}
for(i=0; icache->nservers; i++) {
apr_memcache_server_t *server;
if(APR_SUCCESS != apr_memcache_server_create(pc->pool,cache->servers[i].host,cache->servers[i].port,4,5,50,10000,&server)) {
ctx->set_error(ctx,500,"cache %s: failed to create server %s:%d",cache->cache.name,cache->servers[i].host,cache->servers[i].port);
return;
}
if(APR_SUCCESS != apr_memcache_add_server(pc->memcache,server)) {
ctx->set_error(ctx,500,"cache %s: failed to add server %s:%d",cache->cache.name,cache->servers[i].host,cache->servers[i].port);
return;
}
}
*conn_ = pc;
}
void mapcache_memcache_connection_destructor(void *conn_) {
struct mapcache_memcache_pooled_connection *pc = conn_;
apr_pool_destroy(pc->pool);
free(pc);
}
static mapcache_pooled_connection* _mapcache_memcache_get_conn(mapcache_context *ctx,
mapcache_cache_memcache *cache, mapcache_tile *tile) {
mapcache_pooled_connection *pc;
struct mapcache_memcache_conn_param param;
param.cache = cache;
pc = mapcache_connection_pool_get_connection(ctx,cache->cache.name, mapcache_memcache_connection_constructor, mapcache_memcache_connection_destructor, ¶m);
return pc;
}
static void _mapcache_memcache_release_conn(mapcache_context *ctx, mapcache_pooled_connection *con) {
mapcache_connection_pool_release_connection(ctx, con);
}
static int _mapcache_cache_memcache_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *key;
char *tmpdata;
int rv;
size_t tmpdatasize;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache;
mapcache_pooled_connection *pc;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FALSE;
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile, NULL, " \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
rv = apr_memcache_getp(mpc->memcache,ctx->pool,key,&tmpdata,&tmpdatasize,NULL);
if(rv != APR_SUCCESS) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
if(tmpdatasize == 0) {
rv = MAPCACHE_FALSE;
goto cleanup;
}
rv = MAPCACHE_TRUE;
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
return rv;
}
static void _mapcache_cache_memcache_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *key;
int rv;
char errmsg[120];
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache;
mapcache_pooled_connection *pc;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
GC_CHECK_ERROR(ctx);
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) goto cleanup;
rv = apr_memcache_delete(mpc->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));
goto cleanup;
}
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the memcache server
* \private \memberof mapcache_cache_memcache
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_memcache_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *key;
int rv;
mapcache_cache_memcache *cache = (mapcache_cache_memcache*)pcache;
mapcache_pooled_connection *pc;
mapcache_buffer *encoded_data;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) {
rv = MAPCACHE_FAILURE;
goto cleanup;
}
encoded_data = mapcache_buffer_create(0,ctx->pool);
rv = apr_memcache_getp(mpc->memcache,ctx->pool,key,(char**)&encoded_data->buf,&encoded_data->size,NULL);
if(rv != APR_SUCCESS) {
rv = MAPCACHE_CACHE_MISS;
goto cleanup;
}
if(encoded_data->size == 0) {
ctx->set_error(ctx,500,"memcache cache returned 0-length data for tile %d %d %d\n",tile->x,tile->y,tile->z);
rv = MAPCACHE_FAILURE;
goto cleanup;
}
/* extract the tile modification time from the end of the data returned */
memcpy(
&tile->mtime,
&(((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';
encoded_data->avail = encoded_data->size;
encoded_data->size -= sizeof(apr_time_t);
if(((char*)encoded_data->buf)[0] == '#' && encoded_data->size > 1) {
tile->encoded_data = mapcache_empty_png_decode(ctx,tile->grid_link->grid->tile_sx, tile->grid_link->grid->tile_sy ,encoded_data->buf,&tile->nodata);
} else {
tile->encoded_data = encoded_data;
}
rv = MAPCACHE_SUCCESS;
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
return rv;
}
/**
* \brief push tile data to memcached
*
* writes the content of mapcache_tile::data to the configured memcached instance(s)
* \returns MAPCACHE_FAILURE if there is no data to write, or if the tile isn't locked
* \returns MAPCACHE_SUCCESS if the tile has been successfully written
* \private \memberof mapcache_cache_memcache
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_memcache_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
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;
struct mapcache_memcache_pooled_connection *mpc;
pc = _mapcache_memcache_get_conn(ctx,cache,tile);
GC_CHECK_ERROR(ctx);
mpc = pc->connection;
key = mapcache_util_get_tile_key(ctx, tile,NULL," \r\n\t\f\e\a\b","#");
if(GC_HAS_ERROR(ctx)) goto cleanup;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
if(cache->detect_blank) {
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
encoded_data = mapcache_buffer_create(5,ctx->pool);
((char*)encoded_data->buf)[0] = '#';
memcpy(((char*)encoded_data->buf)+1,tile->raw_image->data,4);
encoded_data->size = 5;
}
}
if(!encoded_data) {
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
encoded_data = tile->encoded_data;
}
/* concatenate the current time to the end of the memcache data so we can extract it out
* when we re-get the tile */
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));
rv = apr_memcache_set(mpc->memcache,key,data,encoded_data->size+sizeof(apr_time_t),expires,0);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500,"failed to store tile %d %d %d to memcache cache %s",
tile->x,tile->y,tile->z,cache->cache.name);
goto cleanup;
}
cleanup:
_mapcache_memcache_release_conn(ctx,pc);
}
/**
* \private \memberof mapcache_cache_memcache
*/
static void _mapcache_cache_memcache_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config)
{
ezxml_t cur_node;
int i = 0;
mapcache_cache_memcache *dcache = (mapcache_cache_memcache*)cache;
for(cur_node = ezxml_child(node,"server"); cur_node; cur_node = cur_node->next) {
dcache->nservers++;
}
if(!dcache->nservers) {
ctx->set_error(ctx,400,"memcache cache %s has no s configured",cache->name);
return;
}
dcache->servers = apr_pcalloc(ctx->pool, dcache->nservers * sizeof(struct mapcache_cache_memcache_server));
for(cur_node = ezxml_child(node,"server"); cur_node; cur_node = cur_node->next) {
ezxml_t xhost = ezxml_child(cur_node,"host");
ezxml_t xport = ezxml_child(cur_node,"port");
if(!xhost || !xhost->txt || ! *xhost->txt) {
ctx->set_error(ctx,400,"cache %s: with no ",cache->name);
return;
} else {
dcache->servers[i].host = apr_pstrdup(ctx->pool,xhost->txt);
}
if(!xport || !xport->txt || ! *xport->txt) {
ctx->set_error(ctx,400,"cache %s: with no ", cache->name);
return;
} else {
char *endptr;
int iport = (int)strtol(xport->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse value %s for memcache cache %s", xport->txt,cache->name);
return;
}
dcache->servers[i].port = iport;
}
i++;
}
dcache->detect_blank = 0;
if ((cur_node = ezxml_child(node, "detect_blank")) != NULL) {
if(!strcasecmp(cur_node->txt,"true")) {
dcache->detect_blank = 1;
}
}
}
/**
* \private \memberof mapcache_cache_memcache
*/
static void _mapcache_cache_memcache_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
mapcache_cache_memcache *dcache = (mapcache_cache_memcache*)cache;
if(!dcache->nservers) {
ctx->set_error(ctx,400,"cache %s has no servers configured",cache->name);
}
}
/**
* \brief creates and initializes a mapcache_memcache_cache
*/
mapcache_cache* mapcache_cache_memcache_create(mapcache_context *ctx)
{
mapcache_cache_memcache *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_memcache));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate memcache cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_MEMCACHE;
cache->cache._tile_get = _mapcache_cache_memcache_get;
cache->cache._tile_exists = _mapcache_cache_memcache_has_tile;
cache->cache._tile_set = _mapcache_cache_memcache_set;
cache->cache._tile_delete = _mapcache_cache_memcache_delete;
cache->cache.configuration_post_config = _mapcache_cache_memcache_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_memcache_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_memcache_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"MEMCACHE support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_multitier.c 0000664 0000000 0000000 00000016102 14653160677 0020207 0 ustar 00root root 0000000 0000000 /******************************************************************************
*
* Project: MapServer
* Purpose: MapCache tile caching: multitier cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without multitierriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
typedef struct mapcache_cache_multitier mapcache_cache_multitier;
struct mapcache_cache_multitier {
mapcache_cache cache;
apr_array_header_t *caches;
};
static int _mapcache_cache_multitier_tile_exists(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
int i;
for(i=0; icaches->nelts; i++) {
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
if(mapcache_cache_tile_exists(ctx, subcache, tile) == MAPCACHE_TRUE) {
return MAPCACHE_TRUE;
}
}
return MAPCACHE_FALSE;
}
static void _mapcache_cache_multitier_tile_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
int i;
for(i=0; icaches->nelts; i++) {
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
mapcache_cache_tile_delete(ctx, subcache, tile);
ctx->clear_errors(ctx); /* ignore errors */
}
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the multitier server
* \private \memberof mapcache_cache_multitier
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_multitier_tile_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
mapcache_cache *subcache;
int i,ret;
subcache = APR_ARRAY_IDX(cache->caches,0,mapcache_cache*);
ret = mapcache_cache_tile_get(ctx, subcache, tile);
if(ret == MAPCACHE_CACHE_MISS) {
for(i=1; icaches->nelts; i++) {
subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
if(mapcache_cache_tile_get(ctx, subcache, tile) == MAPCACHE_SUCCESS) {
ctx->log(ctx,MAPCACHE_DEBUG,"got tile (%s,z=%d,y=%d,x=%d) from secondary cache (%s)",tile->tileset->name, tile->z, tile->y, tile->x, subcache->name);
for(--i;i>=0;i--) {
subcache = APR_ARRAY_IDX(cache->caches,i,mapcache_cache*);
mapcache_cache_tile_set(ctx, subcache, tile);
ctx->clear_errors(ctx); /* silently ignore these errors */
ctx->log(ctx,MAPCACHE_DEBUG,"transferring tile (%s,z=%d,y=%d,x=%d) to cache (%s)",tile->tileset->name, tile->z, tile->y, tile->x, subcache->name);
}
return MAPCACHE_SUCCESS;
}
}
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);
return ret;
}
}
static void _mapcache_cache_multitier_tile_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,cache->caches->nelts-1,mapcache_cache*);
return mapcache_cache_tile_set(ctx, subcache, tile);
}
static void _mapcache_cache_multitier_tile_multi_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
mapcache_cache *subcache = APR_ARRAY_IDX(cache->caches,cache->caches->nelts-1,mapcache_cache*);
return mapcache_cache_tile_multi_set(ctx, subcache, tiles, ntiles);
}
/**
* \private \memberof mapcache_cache_multitier
*/
static void _mapcache_cache_multitier_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *pcache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_multitier *cache = (mapcache_cache_multitier*)pcache;
cache->caches = apr_array_make(ctx->pool,3,sizeof(mapcache_cache*));
for(cur_node = ezxml_child(node,"cache"); cur_node; cur_node = cur_node->next) {
mapcache_cache *refcache = mapcache_configuration_get_cache(config, cur_node->txt);
if(!refcache) {
ctx->set_error(ctx, 400, "multitier cache \"%s\" references cache \"%s\","
" but it is not configured (hint:referenced caches must be declared before this multitier cache in the xml file)", pcache->name, cur_node->txt);
return;
}
APR_ARRAY_PUSH(cache->caches,mapcache_cache*) = refcache;
}
if(cache->caches->nelts == 0) {
ctx->set_error(ctx,400,"multitier cache \"%s\" does not reference any child caches", pcache->name);
}
}
/**
* \private \memberof mapcache_cache_multitier
*/
static void _mapcache_cache_multitier_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
}
/**
* \brief creates and initializes a mapcache_cache_multitier
*/
mapcache_cache* mapcache_cache_multitier_create(mapcache_context *ctx)
{
mapcache_cache_multitier *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_multitier));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate multitier cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_COMPOSITE;
cache->cache._tile_delete = _mapcache_cache_multitier_tile_delete;
cache->cache._tile_get = _mapcache_cache_multitier_tile_get;
cache->cache._tile_exists = _mapcache_cache_multitier_tile_exists;
cache->cache._tile_set = _mapcache_cache_multitier_tile_set;
cache->cache._tile_multi_set = _mapcache_cache_multitier_tile_multi_set;
cache->cache.configuration_post_config = _mapcache_cache_multitier_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_multitier_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
return (mapcache_cache*)cache;
}
mapcache-rel-1-14-1/lib/cache_redis.c 0000664 0000000 0000000 00000025017 14653160677 0017304 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: redis cache backend.
* Author: Boris Manojlovic, Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
* Copyright (c) 2021 Boris Manojlovic
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_REDIS
#include
#include
#include
#include
typedef struct mapcache_cache_redis mapcache_cache_redis;
/**\class mapcache_cache_redis
* \brief a mapcache_cache for redis
* \implements mapcache_cache
*/
struct mapcache_cache_redis {
mapcache_cache cache;
char *host;
int port;
char *key_template;
char *bucket_template;
};
struct redis_conn_params {
mapcache_cache_redis *cache;
};
#define REDIS_GET_CACHE(t) ((mapcache_cache_redis*)t->tileset->_cache)
#define REDIS_GET_TILE_KEY(c, t) (mapcache_util_get_tile_key(c, t, NULL, " \r\n\t\f\e\a\b", "#"))
#define IS_REDIS_ERROR_STATUS(r) (r->type != REDIS_REPLY_STATUS || strncmp(r->str, "OK", 2) != 0)
void mapcache_redis_connection_constructor(mapcache_context *ctx, void **conn_, void *params) {
mapcache_cache_redis *cache = ((struct redis_conn_params*)params)->cache;
redisContext* conn = redisConnect(cache->host, cache->port);
if (!conn || conn->err) {
ctx->set_error(ctx,500, "redis: failed to connect to server %s:%d", cache->host, cache->port);
return;
}
*conn_ = conn;
}
void mapcache_redis_connection_destructor(void *conn_) {
struct redisContext *conn;
conn = (struct redisContext *)conn_;
redisFree(conn);
}
static mapcache_pooled_connection* _redis_get_connection(mapcache_context *ctx, mapcache_cache_redis *cache, mapcache_tile* tile)
{
mapcache_pooled_connection *pc;
struct redis_conn_params params;
params.cache = cache;
pc = mapcache_connection_pool_get_connection(ctx,cache->cache.name,mapcache_redis_connection_constructor,
mapcache_redis_connection_destructor, ¶ms);
return pc;
}
static int _mapcache_cache_redis_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
int returnValue;
redisContext *conn;
redisReply *reply;
mapcache_pooled_connection *pc;
mapcache_cache_redis *cache = (mapcache_cache_redis*)pcache;
char *key = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
returnValue = MAPCACHE_TRUE;
pc = _redis_get_connection(ctx, cache, tile);
conn = pc->connection;
if(!conn) {
return MAPCACHE_FALSE;
}
reply = redisCommand(conn, "EXISTS %s", key);
if(reply->type != REDIS_REPLY_INTEGER) {
returnValue = MAPCACHE_FALSE;
}
else if(reply->integer == 0) {
returnValue = MAPCACHE_FALSE;
}
freeReplyObject(reply);
redisFree(conn);
return returnValue;
}
static void _mapcache_cache_redis_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
redisContext *conn;
redisReply *reply;
mapcache_pooled_connection *pc;
mapcache_cache_redis *cache = (mapcache_cache_redis*)pcache;
char *key = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
GC_CHECK_ERROR(ctx);
pc = _redis_get_connection(ctx, cache, tile);
conn = pc->connection;
if(!conn) {
return;
}
reply = redisCommand(conn, "DEL %s", key);
if(reply->type == REDIS_REPLY_ERROR) {
ctx->set_error(ctx, 500, "redis: failed to delete key %s: %s", key, reply->str);
}
freeReplyObject(reply);
redisFree(conn);
}
static int _mapcache_cache_redis_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
redisContext *conn;
redisReply *reply;
mapcache_pooled_connection *pc;
mapcache_cache_redis *cache = (mapcache_cache_redis*)pcache;
char* key = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
pc = _redis_get_connection(ctx, cache, tile);
conn = pc->connection;
if(!conn) {
return MAPCACHE_FAILURE;
}
reply = redisCommand(conn, "GET %s", key);
if(reply->type != REDIS_REPLY_STRING) {
freeReplyObject(reply);
return MAPCACHE_CACHE_MISS;
}
tile->encoded_data->buf = apr_pcalloc(ctx->pool, reply->len);
memcpy(tile->encoded_data->buf, reply->str, reply->len);
tile->encoded_data->size = reply->len;
if(tile->encoded_data->size == 0) {
freeReplyObject(reply);
ctx->set_error(ctx, 500, "redis: cache returned 0-length data for tile %d %d %d\n",tile->x,tile->y,tile->z);
return MAPCACHE_FAILURE;
}
memcpy(
&tile->mtime,
&(((char*)tile->encoded_data->buf)[tile->encoded_data->size-sizeof(apr_time_t)]),
sizeof(apr_time_t));
((char*)tile->encoded_data->buf)[tile->encoded_data->size+sizeof(apr_time_t)]='\0';
tile->encoded_data->avail = tile->encoded_data->size;
tile->encoded_data->size -= sizeof(apr_time_t);
freeReplyObject(reply);
redisFree(conn);
return MAPCACHE_SUCCESS;
}
/**
* \brief push tile data to redis
*
* writes the content of mapcache_tile::data to the configured redis instance.
* \private \memberof mapcache_cache_redis
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_redis_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
/* set expiration to one day if not configured */
int expires = 86400;
mapcache_pooled_connection *pc;
mapcache_cache_redis *cache = (mapcache_cache_redis*)pcache;
char *key;
char *data;
apr_time_t now;
redisContext *conn;
redisReply *reply;
if(tile->tileset->auto_expire)
expires = tile->tileset->auto_expire;
key = mapcache_util_get_tile_key(ctx, tile, cache->key_template," \r\n\t\f\e\a\b","#");
GC_CHECK_ERROR(ctx);
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
/* concatenate the current time to the end of the memcache data so we can extract it out
* when we re-get the tile */
data = calloc(1,tile->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,tile->encoded_data->buf,tile->encoded_data->size);
memcpy(&(data[tile->encoded_data->size]),&now,sizeof(apr_time_t));
pc = _redis_get_connection(ctx, cache, tile);
conn = pc->connection;
if(!conn) {
return;
}
reply = redisCommand(conn, "SETEX %s %d %b", key, expires, data, tile->encoded_data->size + sizeof(apr_time_t));
if(IS_REDIS_ERROR_STATUS(reply)) {
ctx->set_error(ctx, 500, "failed to store tile %d %d %d to redis cache %s", tile->x, tile->y, tile->z, cache->cache.name);
}
freeReplyObject(reply);
redisFree(conn);
}
/**
* \private \memberof mapcache_cache_redis
*/
static void _mapcache_cache_redis_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) {
ezxml_t xhost,xport;
mapcache_cache_redis *dcache = (mapcache_cache_redis*)cache;
dcache->host = NULL;
dcache->port = 0;
xhost = ezxml_child(node, "host");
xport = ezxml_child(node, "port");
if (!xhost || !xhost->txt || !*xhost->txt) {
ctx->set_error(ctx, 400, "cache %s: redis cache with no ", cache->name);
return;
} else {
dcache->host = apr_pstrdup(ctx->pool, xhost->txt);
}
if (!xport || !xport->txt || !*xport->txt) {
ctx->set_error(ctx, 400, "cache %s: redis cache with no ", cache->name);
return;
} else {
unsigned long int iport = strtoul(xport->txt, NULL, 10);
if(iport == ULONG_MAX && errno == ERANGE) {
ctx->set_error(ctx, 400, "port value %s too large to be parsed for redis cache %s", xport->txt, cache->name);
return;
} else if(iport == 0) {
ctx->set_error(ctx, 400, "failed to parse port value %s for redis cache %s", xport->txt, cache->name);
return;
}
dcache->port = iport;
}
}
/**
* \private \memberof mapcache_cache_redis
*/
static void _mapcache_cache_redis_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache, mapcache_cfg *cfg) {
}
/**
* \brief creates and initializes a mapcache_redis_cache
*/
mapcache_cache* mapcache_cache_redis_create(mapcache_context *ctx)
{
mapcache_cache_redis *cache = apr_pcalloc(ctx->pool, sizeof(mapcache_cache_redis));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate redis cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_REDIS;
cache->cache._tile_get = _mapcache_cache_redis_get;
cache->cache._tile_exists = _mapcache_cache_redis_has_tile;
cache->cache._tile_set = _mapcache_cache_redis_set;
cache->cache._tile_delete = _mapcache_cache_redis_delete;
cache->cache.configuration_post_config = _mapcache_cache_redis_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_redis_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->host = NULL;
cache->port = 6379;
cache->bucket_template = NULL;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_redis_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"redis support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_rest.c 0000664 0000000 0000000 00000152555 14653160677 0017163 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching: HTTP Rest cache backend.
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 2014 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef struct mapcache_cache_rest mapcache_cache_rest;
typedef struct mapcache_cache_s3 mapcache_cache_s3;
typedef struct mapcache_cache_azure mapcache_cache_azure;
typedef struct mapcache_cache_google mapcache_cache_google;
typedef enum {
MAPCACHE_REST_METHOD_GET,
MAPCACHE_REST_METHOD_HEAD,
MAPCACHE_REST_METHOD_PUT,
MAPCACHE_REST_METHOD_POST,
MAPCACHE_REST_METHOD_DELETE
} mapcache_rest_method;
typedef enum {
MAPCACHE_REST_PROVIDER_NONE,
MAPCACHE_REST_PROVIDER_S3,
MAPCACHE_REST_PROVIDER_AZURE,
MAPCACHE_REST_PROVIDER_GOOGLE
} mapcache_rest_provider;
void sha256(const unsigned char *message, unsigned int len, unsigned char *digest);
void hmac_sha256(const unsigned char *message, unsigned int message_len,
const unsigned char *key, unsigned int key_size,
unsigned char *mac, unsigned mac_size);
void hmac_sha1(const char *message, unsigned int message_len,
const unsigned char *key, unsigned int key_size,
void *mac);
void sha_hex_encode(unsigned char *sha, unsigned int sha_size);
char *base64_encode(apr_pool_t *pool, const unsigned char *data, size_t input_length);
typedef struct mapcache_rest_operation mapcache_rest_operation;
struct mapcache_rest_operation {
apr_table_t *headers;
mapcache_rest_method method;
char *tile_url;
char *header_file;
void (*add_headers)(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers);
};
typedef struct mapcache_rest_configuration mapcache_rest_configuration;
struct mapcache_rest_configuration {
apr_table_t *common_headers;
char *tile_url;
char *header_file;
mapcache_rest_operation has_tile;
mapcache_rest_operation get_tile;
mapcache_rest_operation set_tile;
mapcache_rest_operation multi_set_tile;
mapcache_rest_operation delete_tile;
void (*add_headers)(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers);
};
/**\class mapcache_cache_rest
* \brief a mapcache_cache on a 3rd party HTTP Rest API
* \implements mapcache_cache
*/
struct mapcache_cache_rest {
mapcache_cache cache;
mapcache_rest_configuration rest;
int use_redirects;
int timeout;
int connection_timeout;
int detect_blank;
mapcache_rest_provider provider;
};
struct mapcache_cache_s3 {
mapcache_cache_rest cache;
char *id;
char *secret;
char *session_token;
char *region;
char *credentials_file;
};
struct mapcache_cache_azure {
mapcache_cache_rest cache;
char *id;
char *secret;
char *container;
};
struct mapcache_cache_google {
mapcache_cache_rest cache;
char *access;
char *secret;
};
typedef struct {
mapcache_buffer *buffer;
size_t offset;
} buffer_struct;
struct rest_conn_params {
mapcache_cache_rest *cache;
};
void mapcache_rest_connection_constructor(mapcache_context *ctx, void **conn_, void *params) {
CURL *curl_handle = curl_easy_init();
if(!curl_handle) {
ctx->set_error(ctx,500,"failed to create curl handle");
*conn_ = NULL;
return;
}
*conn_ = curl_handle;
}
void mapcache_rest_connection_destructor(void *conn_) {
CURL *curl_handle = (CURL*) conn_;
curl_easy_cleanup(curl_handle);
}
static mapcache_pooled_connection* _rest_get_connection(mapcache_context *ctx, mapcache_cache_rest *cache, mapcache_tile *tile)
{
mapcache_pooled_connection *pc;
struct rest_conn_params params;
params.cache = cache;
pc = mapcache_connection_pool_get_connection(ctx,cache->cache.name,mapcache_rest_connection_constructor,
mapcache_rest_connection_destructor, ¶ms);
if(!GC_HAS_ERROR(ctx) && pc && pc->connection) {
CURL *curl_handle = (CURL*)pc->connection;
curl_easy_reset(curl_handle);
curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, cache->connection_timeout);
curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, cache->timeout);
}
return pc;
}
static size_t buffer_read_callback(void *ptr, size_t size, size_t nmemb, void *stream)
{
buffer_struct *buffer = (buffer_struct*)stream;
void *start = ((char*)(buffer->buffer->buf)) + buffer->offset;
size_t bytes = MAPCACHE_MIN((buffer->buffer->size-buffer->offset),(size * nmemb));
if(bytes) {
memcpy(ptr,start,bytes);
buffer->offset += bytes;
}
return bytes;
}
size_t buffer_write_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
mapcache_buffer *buffer = (mapcache_buffer*)data;
size_t realsize = size * nmemb;
return mapcache_buffer_append(buffer, realsize, ptr);
}
static struct curl_slist* _set_headers(mapcache_context *ctx, CURL *curl, apr_table_t *headers) {
if(!headers) {
return NULL;
} else {
struct curl_slist *curl_headers=NULL;
const apr_array_header_t *array = apr_table_elts(headers);
apr_table_entry_t *elts = (apr_table_entry_t *) array->elts;
int i;
for (i = 0; i < array->nelts; i++) {
if(strlen(elts[i].val) > 0) {
curl_headers = curl_slist_append(curl_headers, apr_pstrcat(ctx->pool,elts[i].key,": ",elts[i].val,NULL));
} else {
curl_headers = curl_slist_append(curl_headers, apr_pstrcat(ctx->pool,elts[i].key,":",NULL));
}
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_headers);
return curl_headers;
}
}
static void _put_request(mapcache_context *ctx, CURL *curl, mapcache_buffer *buffer, char *url, apr_table_t *headers) {
CURLcode res;
buffer_struct data;
mapcache_buffer *response;
struct curl_slist *curl_header_data;
data.buffer = buffer;
data.offset = 0;
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
*/
apr_table_unset(headers, "Content-Length");
#endif
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
/* we want to use our own read function */
curl_easy_setopt(curl, CURLOPT_READFUNCTION, buffer_read_callback);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* HTTP PUT please */
curl_easy_setopt(curl, CURLOPT_PUT, 1L);
/* don't use an Expect: 100 Continue header */
apr_table_set(headers, "Expect", "");
curl_header_data = _set_headers(ctx, curl, headers);
/* specify target URL, and note that this URL should include a file
* name, not only a directory */
curl_easy_setopt(curl, CURLOPT_URL, url);
/* 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 */
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! */
res = curl_easy_perform(curl);
/* 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 {
long http_code;
curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
if(http_code != 200 && http_code != 201 && http_code != 204) {
char *msg = response->buf;
msg[response->size]=0;
ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest put with code %ld: %s", http_code, msg);
}
}
curl_slist_free_all(curl_header_data);
}
static int _head_request(mapcache_context *ctx, CURL *curl, char *url, apr_table_t *headers) {
CURLcode res;
long http_code;
struct curl_slist *curl_header_data;
curl_header_data = _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 */
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
/* Now run off and do what you've been told! */
res = curl_easy_perform(curl);
/* 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;
} else {
curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
}
curl_slist_free_all(curl_header_data);
return (int)http_code;
}
static int _delete_request(mapcache_context *ctx, CURL *curl, char *url, apr_table_t *headers) {
CURLcode res;
long http_code;
struct curl_slist *curl_header_data;
curl_header_data = _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 */
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
/* Now run off and do what you've been told! */
res = curl_easy_perform(curl);
/* Check for errors */
if(res != CURLE_OK) {
ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest delete %s",curl_easy_strerror(res));
http_code = 500;
} else {
curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
}
curl_slist_free_all(curl_header_data);
return (int)http_code;
}
static mapcache_buffer* _get_request(mapcache_context *ctx, CURL *curl, char *url, apr_table_t *headers) {
CURLcode res;
mapcache_buffer *data = NULL;
long http_code;
struct curl_slist *curl_header_data;
curl_header_data = _set_headers(ctx, curl, headers);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
data = mapcache_buffer_create(4000, ctx->pool);
/* 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 *)data);
/* specify target URL, and note that this URL should include a file
* name, not only a directory */
curl_easy_setopt(curl, CURLOPT_URL, url);
/* Now run off and do what you've been told! */
res = curl_easy_perform(curl);
/* 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 */
if(http_code == 403) {
char *msg = data->buf;
while(msg && *msg) {
if(!strncmp(msg,"NoSuchKey",strlen("NoSuchKey"))) {
ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest get with code %ld: %s", http_code, msg);
http_code = 404;
data = NULL;
break;
}
msg++;
}
}
if(http_code != 200 && http_code != 404) {
char *msg = data->buf;
msg[data->size]=0;
ctx->set_error(ctx, 500, "curl_easy_perform() failed in rest get with code %ld: %s", http_code, msg);
}
if(http_code == 404) {
data = NULL; /* not an error */
}
}
curl_slist_free_all(curl_header_data);
return data;
}
/**
* @brief _mapcache_cache_rest_add_headers_from_file populate header table from entries found in file
* @param ctx
* @param file the file from which headers should be read
* @param headers the output table which will be populated
*/
void _mapcache_cache_rest_add_headers_from_file(mapcache_context *ctx, char *file, apr_table_t *headers) {
apr_status_t rv;
apr_file_t *f;
if((rv=apr_file_open(&f, file, APR_FOPEN_READ|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,APR_OS_DEFAULT,
ctx->pool)) == APR_SUCCESS) {
char line[8096];
while( (rv = apr_file_gets(line,8096,f))== APR_SUCCESS) {
char *header_name=line, *header_val=line, *header_endval;
int found_token = MAPCACHE_FALSE;
/*search for header delimiter (:)*/
while(header_val && *header_val) {
if(*header_val == ':') {
*header_val = '\0';
found_token = MAPCACHE_TRUE;
break;
}
header_val++;
}
if(!found_token) {
/* malformed line, silently skip it */
continue;
}
header_val++;
if(!*header_val) {
/* malformed/empty line, skip it */
continue;
}
header_endval = header_val;
while(*header_endval) {
if(*header_endval == '\r' || *header_endval == '\n') {
*header_endval = '\0';
break;
}
header_endval++;
}
if(!*header_val) {
/* empty header value, skip it */
continue;
}
apr_table_set(headers, header_name, header_val);
}
apr_file_close(f);
} else {
ctx->set_error(ctx,500,"rest cache: failed to access header file");
}
}
apr_table_t* _mapcache_cache_rest_headers(mapcache_context *ctx, mapcache_tile *tile, mapcache_rest_configuration *config,
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);
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(config->header_file) {
_mapcache_cache_rest_add_headers_from_file(ctx,config->header_file,ret);
if(GC_HAS_ERROR(ctx)) {
return NULL;
}
}
if(operation->headers) {
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);
}
}
if(operation->header_file) {
_mapcache_cache_rest_add_headers_from_file(ctx,operation->header_file,ret);
if(GC_HAS_ERROR(ctx)) {
return NULL;
}
}
return ret;
}
/* Converts an integer value to its hex character*/
static char to_hex(char code) {
static char hex[] = "0123456789ABCDEF";
return hex[code & 15];
}
/* Returns a url-encoded version of str */
static char *url_encode(apr_pool_t *pool, char *str) {
char *pstr = str, *buf = apr_pcalloc(pool, strlen(str) * 3 + 1), *pbuf = buf;
while (*pstr) {
if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~' || *pstr=='/')
*pbuf++ = *pstr;
else if (*pstr == ' ')
*pbuf++ = '+';
else
*pbuf++ = '%', *pbuf++ = to_hex(*pstr >> 4), *pbuf++ = to_hex(*pstr & 15);
pstr++;
}
*pbuf = '\0';
return buf;
}
/**
* \brief return url for given tile given a template
*
* \param tile the tile to get the key from
* \param template the template to build the url from
* \param path pointer to a char* that will contain the url
* \param r
* \private \memberof mapcache_cache_rest
*/
static void _mapcache_cache_rest_tile_url(mapcache_context *ctx, mapcache_tile *tile, mapcache_rest_configuration *config,
mapcache_rest_operation *operation, char **url)
{
char *slashptr,*path;
int cnt=0;
if(operation && operation->tile_url) {
*url = apr_pstrdup(ctx->pool, operation->tile_url);
} else {
*url = apr_pstrdup(ctx->pool, config->tile_url);
}
*url = mapcache_util_str_replace(ctx->pool, *url, "{tileset}", tile->tileset->name);
*url = mapcache_util_str_replace(ctx->pool, *url, "{grid}", tile->grid_link->grid->name);
*url = mapcache_util_str_replace(ctx->pool, *url, "{ext}",
tile->tileset->format?tile->tileset->format->extension:"png");
if(strstr(*url,"{x}"))
*url = mapcache_util_str_replace(ctx->pool,*url, "{x}",
apr_psprintf(ctx->pool,"%d",tile->x));
else
*url = mapcache_util_str_replace(ctx->pool,*url, "{inv_x}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1));
if(strstr(*url,"{y}"))
*url = mapcache_util_str_replace(ctx->pool,*url, "{y}",
apr_psprintf(ctx->pool,"%d",tile->y));
else
*url = mapcache_util_str_replace(ctx->pool,*url, "{inv_y}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1));
if(strstr(*url,"{z}"))
*url = mapcache_util_str_replace(ctx->pool,*url, "{z}",
apr_psprintf(ctx->pool,"%d",tile->z));
else
*url = mapcache_util_str_replace(ctx->pool,*url, "{inv_z}",
apr_psprintf(ctx->pool,"%d",
tile->grid_link->grid->nlevels - tile->z - 1));
if(tile->dimensions) {
int i;
if(strstr(*url,"{dim")) {
char *dimstring="";
i = tile->dimensions->nelts;
while(i--) {
char *single_dim;
mapcache_requested_dimension *entry = APR_ARRAY_IDX(tile->dimensions,i,mapcache_requested_dimension*);
if(!entry->cached_value) {
ctx->set_error(ctx,500,"BUG: dimension (%s) not defined",entry->dimension->name);
return;
}
dimstring = apr_pstrcat(ctx->pool,dimstring,"#",entry->dimension->name,"#",entry->cached_value,NULL);
single_dim = apr_pstrcat(ctx->pool,"{dim:",entry->dimension->name,"}",NULL);
if(strstr(*url,single_dim)) {
*url = mapcache_util_str_replace(ctx->pool,*url, single_dim, entry->cached_value);
}
}
*url = mapcache_util_str_replace(ctx->pool,*url, "{dim}", dimstring);
}
}
/* url-encode everything after the host name */
/* find occurence of third "/" in url */
slashptr = *url;
while(*slashptr) {
if(*slashptr == '/') cnt++;
if(cnt == 3) break;
slashptr++;
}
if(!*slashptr) {
ctx->set_error(ctx,500,"invalid rest url provided, expecting http(s)://server/path format");
return;
}
path=slashptr;
path = url_encode(ctx->pool,path);
*slashptr=0;
*url = apr_pstrcat(ctx->pool,*url,path,NULL);
/*ctx->log(ctx,MAPCACHE_DEBUG,"rest url: %s",*url);*/
}
// Simple comparison function for comparing two HTTP header names that are
// embedded within an HTTP header line, returning true if header1 comes
// before header2 alphabetically, false if not
static int headerle(const char *header1, const char *header2)
{
while (1) {
if (*header1 == ':') {
return (*header2 == ':');
}
else if (*header2 == ':') {
return 0;
}
else if (*header2 < *header1) {
return 0;
}
else if (*header2 > *header1) {
return 1;
}
header1++, header2++;
}
}
// Replace this with merge sort eventually, it's the best stable sort. But
// since typically the number of elements being sorted is small, it doesn't
// matter that much which sort is used, and gnome sort is the world's simplest
// stable sort. Added a slight twist to the standard gnome_sort - don't go
// forward +1, go forward to the last highest index considered. This saves
// all the string comparisons that would be done "going forward", and thus
// only does the necessary string comparisons to move values back into their
// sorted position.
static void header_gnome_sort(char **headers, int size)
{
int i = 0, last_highest = 0;
while (i < size) {
if ((i == 0) || headerle(headers[i - 1], headers[i])) {
i = ++last_highest;
}
else {
char *tmp = headers[i];
headers[i] = headers[i - 1];
headers[--i] = tmp;
}
}
}
static const char* my_apr_table_get(apr_table_t *t, char *key) {
const char *val = apr_table_get(t,key);
if(!val) val = "";
return val;
}
static void _mapcache_cache_google_headers_add(mapcache_context *ctx, const char* method, mapcache_cache_rest *rcache, mapcache_tile *tile, char *url, apr_table_t *headers)
{
char *stringToSign, **aheaders, *resource = url, x_amz_date[64];
const char *head;
const apr_array_header_t *ahead;
apr_table_entry_t *elts;
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);
apr_table_set(headers,"x-amz-date",x_amz_date);
if(!strcmp(method,"PUT")) {
assert(tile->encoded_data);
apr_md5(sha,tile->encoded_data->buf,tile->encoded_data->size);
apr_base64_encode(b64, (char*)sha, 16);
apr_table_set(headers, "Content-MD5", b64);
}
head = my_apr_table_get(headers, "Content-MD5");
stringToSign=apr_pstrcat(ctx->pool, method, "\n", head, "\n", NULL);
head = my_apr_table_get(headers, "Content-Type");
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);
ahead = apr_table_elts(headers);
aheaders = apr_pcalloc(ctx->pool, ahead->nelts * sizeof(char*));
elts = (apr_table_entry_t *) ahead->elts;
for (i = 0; i < ahead->nelts; i++) {
if(!strncmp(elts[i].key,"x-amz-",6)) {
char *k = aheaders[nCanonicalHeaders] = apr_pstrdup(ctx->pool, elts[i].key);
while(*k) {
*k = tolower(*k);
k++;
}
nCanonicalHeaders++;
}
}
header_gnome_sort(aheaders, nCanonicalHeaders);
for(i=0; ipool, stringToSign, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL);
}
/* find occurence of third "/" in url */
while(*resource) {
if(*resource == '/') cnt++;
if(cnt == 3) break;
resource++;
}
if(!*resource) {
ctx->set_error(ctx,500,"invalid google url provided");
return;
}
stringToSign = apr_pstrcat(ctx->pool, stringToSign, resource, NULL);
hmac_sha1(stringToSign, strlen(stringToSign), (unsigned char*)google->secret, strlen(google->secret), sha);
apr_base64_encode(b64, (char*)sha, 20);
apr_table_set( headers, "Authorization", apr_pstrcat(ctx->pool,"AWS ", google->access, ":", b64, NULL));
}
static void _mapcache_cache_azure_headers_add(mapcache_context *ctx, const char* method, mapcache_cache_rest *rcache, mapcache_tile *tile, char *url, apr_table_t *headers)
{
char *stringToSign, **aheaders, *canonical_headers="", *canonical_resource=NULL, *resource = url, x_ms_date[64];
const char *head;
const apr_array_header_t *ahead;
apr_table_entry_t *elts;
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);
apr_table_set(headers,"x-ms-date",x_ms_date);
apr_table_set(headers,"x-ms-version","2009-09-19");
apr_table_set(headers,"x-ms-blob-type","BlockBlob");
stringToSign = apr_pstrcat(ctx->pool, method, "\n", NULL);
head = my_apr_table_get(headers, "Content-Encoding");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Content-Language");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Content-Length");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Content-MD5");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Content-Type");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Date");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "If-Modified-Since");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "If-Match");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "If-None-Match");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "If-Unmodified-Since");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
head = my_apr_table_get(headers, "Range");
stringToSign=apr_pstrcat(ctx->pool, stringToSign, head, "\n", NULL);
ahead = apr_table_elts(headers);
aheaders = apr_pcalloc(ctx->pool, ahead->nelts * sizeof(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;
k = aheaders[nCanonicalHeaders] = apr_pstrdup(ctx->pool, elts[i].key);
while(*k) {
*k = tolower(*k);
k++;
}
nCanonicalHeaders++;
}
header_gnome_sort(aheaders, nCanonicalHeaders);
for(i=0; ipool, canonical_headers, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL);
}
/* find occurence of third "/" in url */
while(*resource) {
if(*resource == '/') cnt++;
if(cnt == 3) break;
resource++;
}
if(!*resource) {
ctx->set_error(ctx,500,"invalid azure url provided");
return;
}
canonical_resource = apr_pstrcat(ctx->pool, "/", azure->id, resource, NULL);
stringToSign = apr_pstrcat(ctx->pool, stringToSign, canonical_headers, canonical_resource, NULL);
keyub64 = (char*)apr_pcalloc(ctx->pool, apr_base64_decode_len(azure->secret));
apr_base64_decode(keyub64, azure->secret);
hmac_sha256((unsigned char*)stringToSign, strlen(stringToSign), (unsigned char*)keyub64, strlen(keyub64), sha, 32);
b64sign = (char*)apr_pcalloc(ctx->pool, apr_base64_encode_len(32));
apr_base64_encode(b64sign, (char*)sha, 32);
apr_table_set( headers, "Authorization", apr_pstrcat(ctx->pool,"SharedKey ", azure->id, ":", b64sign, NULL));
}
static void _remove_lineends(char *str) {
if(str) {
size_t len = strlen(str);
while(len>0) {
if(str[len-1] == '\n' || str[len-1] == '\r') {
str[len-1] = '\0';
len--;
} else {
break;
}
}
}
}
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)
{
unsigned char sha1[65],sha2[65];
int cnt=0,i;
time_t now = time(NULL);
struct tm *tnow = gmtime(&now);
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;
char *aws_access_key_id = NULL, *aws_secret_access_key = NULL, *aws_security_token = NULL;
sha1[64]=sha2[64]=0;
assert(rcache->provider == MAPCACHE_REST_PROVIDER_S3);
s3 = (mapcache_cache_s3*)rcache;
if(s3->credentials_file) {
apr_status_t rv;
apr_file_t *f;
if((rv=apr_file_open(&f, s3->credentials_file,
APR_FOPEN_READ|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,APR_OS_DEFAULT,
ctx->pool)) == APR_SUCCESS) {
// Line length buffer increased to handle longer session tokens; see:
// https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html
char line[4096];
if( (rv = apr_file_gets(line,4096,f))== APR_SUCCESS) {
_remove_lineends(line);
aws_access_key_id = apr_pstrdup(ctx->pool,line);
}
if( (rv = apr_file_gets(line,4096,f))== APR_SUCCESS) {
_remove_lineends(line);
aws_secret_access_key = apr_pstrdup(ctx->pool,line);
}
if( (rv = apr_file_gets(line,4096,f))== APR_SUCCESS) {
_remove_lineends(line);
aws_security_token = apr_pstrdup(ctx->pool,line);
}
apr_file_close(f);
if(!aws_access_key_id || !*aws_access_key_id|| !aws_secret_access_key ||!*aws_secret_access_key) {
ctx->set_error(ctx,500,"failed to read access or secret key from credentials file");
}
if(aws_security_token && !*aws_security_token) {
aws_security_token = NULL;
}
} else {
ctx->set_error(ctx,500,"failed to access S3 credential config");
}
} else {
aws_access_key_id = s3->id;
aws_secret_access_key = s3->secret;
aws_security_token = s3->session_token;
}
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);
} else {
/* sha256 hash of empty string */
memcpy(sha1,"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",64);
}
apr_table_set(headers,"x-amz-content-sha256", (char*)sha1);
/* sha1 contains the hash of the payload */
/* find occurence of third "/" in url */
while(*resource) {
if(*resource == '/') cnt++;
if(cnt == 3) break;
resource++;
}
if(!*resource) {
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);
if(aws_security_token) {
apr_table_set(headers, "x-amz-security-token", aws_security_token);
}
canonical_request = apr_pstrcat(ctx->pool, method, "\n" ,resource, "\n\n",NULL);
ahead = apr_table_elts(headers);
aheaders = apr_pcalloc(ctx->pool, ahead->nelts * sizeof(char*));
elts = (apr_table_entry_t *) ahead->elts;
for (i = 0; i < ahead->nelts; i++) {
char *k = aheaders[i] = apr_pstrdup(ctx->pool, elts[i].key);
while(*k) {
*k = tolower(*k);
k++;
}
}
header_gnome_sort(aheaders, ahead->nelts);
for(i=0; inelts; i++) {
canonical_request = apr_pstrcat(ctx->pool, canonical_request, aheaders[i],":",apr_table_get(headers,aheaders[i]),"\n",NULL);
}
canonical_request = apr_pstrcat(ctx->pool, canonical_request, "\n", NULL);
for(i=0; inelts; i++) {
if(i==ahead->nelts-1) {
canonical_request = apr_pstrcat(ctx->pool, canonical_request, aheaders[i],NULL);
} else {
canonical_request = apr_pstrcat(ctx->pool, canonical_request, aheaders[i],";",NULL);
}
}
canonical_request = apr_pstrcat(ctx->pool, canonical_request, "\n", sha1, NULL);
//printf("canonical request: %s\n",canonical_request);
tosign = apr_pstrcat(ctx->pool, "AWS4-HMAC-SHA256\n",x_amz_date,"\n",NULL);
x_amz_date[8]=0;
sha256((unsigned char*)canonical_request, strlen(canonical_request), sha1);
sha_hex_encode(sha1,32);
tosign = apr_pstrcat(ctx->pool, tosign, x_amz_date, "/", s3->region, "/s3/aws4_request\n", sha1,NULL);
//printf("key to sign: %s\n",tosign);
key = apr_pstrcat(ctx->pool, "AWS4", aws_secret_access_key, NULL);
hmac_sha256((unsigned char*)x_amz_date, 8, (unsigned char*)key, strlen(key), sha1, 32);
hmac_sha256((unsigned char*)s3->region, strlen(s3->region), sha1, 32, sha2, 32);
hmac_sha256((unsigned char*)"s3", 2, sha2, 32, sha1, 32);
hmac_sha256((unsigned char*)"aws4_request", 12, sha1, 32, sha2, 32);
hmac_sha256((unsigned char*)tosign, strlen(tosign), sha2, 32, sha1, 32);
sha_hex_encode(sha1,32);
auth = apr_pstrcat(ctx->pool, "AWS4-HMAC-SHA256 Credential=",aws_access_key_id,"/",x_amz_date,"/",s3->region,"/s3/aws4_request,SignedHeaders=",NULL);
for(i=0; inelts; i++) {
if(i==ahead->nelts-1) {
auth = apr_pstrcat(ctx->pool, auth, aheaders[i],NULL);
} else {
auth = apr_pstrcat(ctx->pool, auth, aheaders[i],";",NULL);
}
}
auth = apr_pstrcat(ctx->pool, auth, ",Signature=", sha1, NULL);
apr_table_set(headers, "Authorization", auth);
}
static void _mapcache_cache_s3_put_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_s3_headers_add(ctx, "PUT", pcache, tile, url, headers);
}
static void _mapcache_cache_s3_get_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_s3_headers_add(ctx, "GET", pcache, tile, url, headers);
}
static void _mapcache_cache_s3_head_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_s3_headers_add(ctx, "HEAD", pcache, tile, url, headers);
}
static void _mapcache_cache_s3_delete_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_s3_headers_add(ctx, "DELETE", pcache, tile, url, headers);
}
static void _mapcache_cache_azure_put_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_azure_headers_add(ctx, "PUT", pcache, tile, url, headers);
}
static void _mapcache_cache_azure_get_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_azure_headers_add(ctx, "GET", pcache, tile, url, headers);
}
static void _mapcache_cache_azure_head_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_azure_headers_add(ctx, "HEAD", pcache, tile, url, headers);
}
static void _mapcache_cache_azure_delete_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_azure_headers_add(ctx, "DELETE", pcache, tile, url, headers);
}
static void _mapcache_cache_google_put_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_google_headers_add(ctx, "PUT", pcache, tile, url, headers);
}
static void _mapcache_cache_google_get_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_google_headers_add(ctx, "GET", pcache, tile, url, headers);
}
static void _mapcache_cache_google_head_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_google_headers_add(ctx, "HEAD", pcache, tile, url, headers);
}
static void _mapcache_cache_google_delete_headers_add(mapcache_context *ctx, mapcache_cache_rest *pcache, mapcache_tile *tile, char *url, apr_table_t *headers) {
_mapcache_cache_google_headers_add(ctx, "DELETE", pcache, tile, url, headers);
}
static int _mapcache_cache_rest_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_rest *rcache = (mapcache_cache_rest*)pcache;
char *url;
apr_table_t *headers;
int status;
mapcache_pooled_connection *pc;
CURL *curl;
_mapcache_cache_rest_tile_url(ctx, tile, &rcache->rest, &rcache->rest.has_tile, &url);
headers = _mapcache_cache_rest_headers(ctx, tile, &rcache->rest, &rcache->rest.has_tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FAILURE;
if(rcache->rest.add_headers) {
rcache->rest.add_headers(ctx,rcache,tile,url,headers);
}
if(rcache->rest.has_tile.add_headers) {
rcache->rest.has_tile.add_headers(ctx,rcache,tile,url,headers);
}
pc = _rest_get_connection(ctx, rcache, tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FAILURE;
curl = pc->connection;
status = _head_request(ctx, curl, url, headers);
if(GC_HAS_ERROR(ctx)) {
mapcache_connection_pool_invalidate_connection(ctx,pc);
return MAPCACHE_FAILURE;
}
mapcache_connection_pool_release_connection(ctx,pc);
if( status == 200)
return MAPCACHE_TRUE;
else
return MAPCACHE_FALSE;
}
static void _mapcache_cache_rest_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_rest *rcache = (mapcache_cache_rest*)pcache;
char *url;
apr_table_t *headers;
int status;
mapcache_pooled_connection *pc;
CURL *curl;
_mapcache_cache_rest_tile_url(ctx, tile, &rcache->rest, &rcache->rest.delete_tile, &url);
headers = _mapcache_cache_rest_headers(ctx, tile, &rcache->rest, &rcache->rest.delete_tile);
GC_CHECK_ERROR(ctx);
if(rcache->rest.add_headers) {
rcache->rest.add_headers(ctx,rcache,tile,url,headers);
}
if(rcache->rest.delete_tile.add_headers) {
rcache->rest.delete_tile.add_headers(ctx,rcache,tile,url,headers);
}
pc = _rest_get_connection(ctx, rcache, tile);
GC_CHECK_ERROR(ctx);
curl = pc->connection;
status = _delete_request(ctx, curl, url, headers);
if(GC_HAS_ERROR(ctx)) {
mapcache_connection_pool_invalidate_connection(ctx,pc);
return;
}
mapcache_connection_pool_release_connection(ctx,pc);
if(status!=200 && status!=202 && status!=204 && status!=404 && status!=410) {
//ctx->set_error(ctx,500,"rest delete returned code %d", status);
}
}
/**
* \brief get file content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored in the file
* \private \memberof mapcache_cache_rest
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_rest_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_rest *rcache = (mapcache_cache_rest*)pcache;
char *url;
apr_table_t *headers;
mapcache_pooled_connection *pc;
CURL *curl;
_mapcache_cache_rest_tile_url(ctx, tile, &rcache->rest, &rcache->rest.get_tile, &url);
if(tile->allow_redirect && rcache->use_redirects) {
tile->redirect = url;
return MAPCACHE_SUCCESS;
}
headers = _mapcache_cache_rest_headers(ctx, tile, &rcache->rest, &rcache->rest.get_tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FAILURE;
if(rcache->rest.add_headers) {
rcache->rest.add_headers(ctx,rcache,tile,url,headers);
}
if(rcache->rest.get_tile.add_headers) {
rcache->rest.get_tile.add_headers(ctx,rcache,tile,url,headers);
}
pc = _rest_get_connection(ctx, rcache, tile);
if(GC_HAS_ERROR(ctx))
return MAPCACHE_FAILURE;
curl = pc->connection;
tile->encoded_data = _get_request(ctx, curl, url, headers);
if(GC_HAS_ERROR(ctx)) {
mapcache_connection_pool_invalidate_connection(ctx,pc);
return MAPCACHE_FAILURE;
}
mapcache_connection_pool_release_connection(ctx,pc);
if(!tile->encoded_data)
return MAPCACHE_CACHE_MISS;
return MAPCACHE_SUCCESS;
}
static void _mapcache_cache_rest_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
mapcache_cache_rest *rcache = (mapcache_cache_rest*)pcache;
char *url;
apr_table_t *headers;
mapcache_pooled_connection *pc;
CURL *curl;
if(rcache->detect_blank) {
if(tile->nodata) {
return;
}
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
if(tile->raw_image->data[3] == 0) {
/* We have a blank (uniform) image who's first pixel is fully transparent, thus the whole image is transparent */
tile->nodata = 1;
return;
}
}
}
_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);
GC_CHECK_ERROR(ctx);
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
apr_table_set(headers,"Content-Length",apr_psprintf(ctx->pool,"%lu",tile->encoded_data->size));
if(tile->tileset->format && tile->tileset->format->mime_type)
apr_table_set(headers, "Content-Type", tile->tileset->format->mime_type);
else {
mapcache_image_format_type imgfmt = mapcache_imageio_header_sniff(ctx,tile->encoded_data);
if(imgfmt == GC_JPEG) {
apr_table_set(headers, "Content-Type", "image/jpeg");
} else if (imgfmt == GC_PNG) {
apr_table_set(headers, "Content-Type", "image/png");
}
}
if(rcache->rest.add_headers) {
rcache->rest.add_headers(ctx,rcache,tile,url,headers);
}
if(rcache->rest.set_tile.add_headers) {
rcache->rest.set_tile.add_headers(ctx,rcache,tile,url,headers);
}
pc = _rest_get_connection(ctx, rcache, tile);
GC_CHECK_ERROR(ctx);
curl = pc->connection;
_put_request(ctx, curl, tile->encoded_data, url, headers);
if(GC_HAS_ERROR(ctx)) {
mapcache_connection_pool_invalidate_connection(ctx,pc);
return;
}
mapcache_connection_pool_release_connection(ctx,pc);
}
static void _mapcache_cache_rest_operation_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_rest_operation *op)
{
ezxml_t cur_node;
if ((cur_node = ezxml_child(node,"headers")) != NULL) {
ezxml_t header_node;
op->headers = apr_table_make(ctx->pool,3);
for(header_node = cur_node->child; header_node; header_node = header_node->sibling) {
apr_table_set(op->headers, header_node->name, header_node->txt);
}
}
if ((cur_node = ezxml_child(node,"header_file")) != NULL) {
op->header_file = apr_pstrdup(ctx->pool, cur_node->txt);
}
}
/**
* \private \memberof mapcache_cache_rest
*/
static void _mapcache_cache_rest_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_rest *dcache = (mapcache_cache_rest*)cache;
if ((cur_node = ezxml_child(node,"url")) != NULL) {
dcache->rest.tile_url = apr_pstrdup(ctx->pool,cur_node->txt);
}
if ((cur_node = ezxml_child(node,"use_redirects")) != NULL) {
if(!strcasecmp(cur_node->txt,"true")) {
dcache->use_redirects = 1;
}
}
if ((cur_node = ezxml_child(node,"connection_timeout")) != NULL) {
char *endptr;
dcache->connection_timeout = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0 || dcache->connection_timeout<1) {
ctx->set_error(ctx,400,"invalid rest cache \"%s\" (positive integer expected)",
cur_node->txt);
return;
}
} else {
dcache->connection_timeout = 30;
}
if ((cur_node = ezxml_child(node,"timeout")) != NULL) {
char *endptr;
dcache->timeout = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0 || dcache->timeout<1) {
ctx->set_error(ctx,400,"invalid rest cache \"%s\" (positive integer expected)",
cur_node->txt);
return;
}
} else {
dcache->timeout = 120;
}
dcache->detect_blank = 0;
if ((cur_node = ezxml_child(node, "detect_blank")) != NULL) {
if(strcasecmp(cur_node->txt,"false")) {
dcache->detect_blank = 1;
}
}
if ((cur_node = ezxml_child(node,"headers")) != NULL) {
ezxml_t header_node;
dcache->rest.common_headers = apr_table_make(ctx->pool,3);
for(header_node = cur_node->child; header_node; header_node = header_node->sibling) {
apr_table_set(dcache->rest.common_headers, header_node->name, header_node->txt);
}
}
if ((cur_node = ezxml_child(node,"header_file")) != NULL) {
dcache->rest.header_file = apr_pstrdup(ctx->pool, cur_node->txt);
}
for(cur_node = ezxml_child(node,"operation"); cur_node; cur_node = cur_node->next) {
char *type = (char*)ezxml_attr(cur_node,"type");
if(!type) {
ctx->set_error(ctx,400," with no \"type\" attribute in cache (%s)", cache->name);
return;
}
if(!strcasecmp(type,"put")) {
_mapcache_cache_rest_operation_parse_xml(ctx,cur_node,cache,&dcache->rest.set_tile);
GC_CHECK_ERROR(ctx);
} else if(!strcasecmp(type,"get")) {
_mapcache_cache_rest_operation_parse_xml(ctx,cur_node,cache,&dcache->rest.get_tile);
GC_CHECK_ERROR(ctx);
} else if(!strcasecmp(type,"head")) {
_mapcache_cache_rest_operation_parse_xml(ctx,cur_node,cache,&dcache->rest.has_tile);
GC_CHECK_ERROR(ctx);
} else if(!strcasecmp(type,"delete")) {
_mapcache_cache_rest_operation_parse_xml(ctx,cur_node,cache,&dcache->rest.delete_tile);
GC_CHECK_ERROR(ctx);
} else {
ctx->set_error(ctx,400," with unknown \"type\" (%s) attribute in cache (%s) (expecting put, get, head or delete)", type, cache->name);
return;
}
}
}
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;
_mapcache_cache_rest_configuration_parse_xml(ctx, node, cache, config);
GC_CHECK_ERROR(ctx);
if ((cur_node = ezxml_child(node,"access")) != NULL) {
google->access = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"google cache (%s) is missing required child", cache->name);
return;
}
if ((cur_node = ezxml_child(node,"secret")) != NULL) {
google->secret = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"google cache (%s) is missing required child", cache->name);
return;
}
}
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;
_mapcache_cache_rest_configuration_parse_xml(ctx, node, cache, config);
GC_CHECK_ERROR(ctx);
if ((cur_node = ezxml_child(node,"credentials_file")) != NULL) {
s3->credentials_file = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
if ((cur_node = ezxml_child(node,"id")) != NULL) {
s3->id = apr_pstrdup(ctx->pool, cur_node->txt);
} else if ( getenv("AWS_ACCESS_KEY_ID")) {
s3->id = apr_pstrdup(ctx->pool,getenv("AWS_ACCESS_KEY_ID"));
} else {
ctx->set_error(ctx,400,"s3 cache (%s) is missing required child or AWS_ACCESS_KEY_ID environment", cache->name);
return;
}
if ((cur_node = ezxml_child(node,"secret")) != NULL) {
s3->secret = apr_pstrdup(ctx->pool, cur_node->txt);
} else if ( getenv("AWS_SECRET_ACCESS_KEY")) {
s3->secret = apr_pstrdup(ctx->pool,getenv("AWS_SECRET_ACCESS_KEY"));
} else {
ctx->set_error(ctx,400,"s3 cache (%s) is missing required child or AWS_SECRET_ACCESS_KEY environment", cache->name);
return;
}
if ((cur_node = ezxml_child(node,"session_token")) != NULL) {
s3->session_token = apr_pstrdup(ctx->pool, cur_node->txt);
} else if ( getenv("AWS_SESSION_TOKEN")) {
s3->session_token = apr_pstrdup(ctx->pool,getenv("AWS_SESSION_TOKEN"));
} else {
s3->session_token = NULL;
}
}
if ((cur_node = ezxml_child(node,"region")) != NULL) {
s3->region = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"s3 cache (%s) is missing required child", cache->name);
return;
}
}
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;
_mapcache_cache_rest_configuration_parse_xml(ctx, node, cache, config);
GC_CHECK_ERROR(ctx);
if ((cur_node = ezxml_child(node,"id")) != NULL) {
azure->id = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"azure cache (%s) is missing required child", cache->name);
return;
}
if ((cur_node = ezxml_child(node,"secret")) != NULL) {
azure->secret = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"azure cache (%s) is missing required child", cache->name);
return;
}
if ((cur_node = ezxml_child(node,"container")) != NULL) {
azure->container = apr_pstrdup(ctx->pool, cur_node->txt);
} else {
ctx->set_error(ctx,400,"azure cache (%s) is missing required child", cache->name);
return;
}
}
/**
* \private \memberof mapcache_cache_rest
*/
static void _mapcache_cache_rest_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache,
mapcache_cfg *cfg)
{
mapcache_cache_rest *dcache = (mapcache_cache_rest*)cache;
if(!dcache->rest.tile_url) {
if(!dcache->rest.delete_tile.tile_url) {
ctx->set_error(ctx,400, "rest cache (%s) has no global and no for delete_tile operation", cache->name);
return;
}
if(!dcache->rest.get_tile.tile_url) {
ctx->set_error(ctx,400, "rest cache (%s) has no global and no for get_tile operation", cache->name);
return;
}
if(!dcache->rest.set_tile.tile_url) {
ctx->set_error(ctx,400, "rest cache (%s) has no global and no for set_tile operation", cache->name);
return;
}
}
}
void mapcache_cache_rest_init(mapcache_context *ctx, mapcache_cache_rest *cache) {
cache->use_redirects = 0;
cache->rest.get_tile.method = MAPCACHE_REST_METHOD_GET;
cache->rest.set_tile.method = MAPCACHE_REST_METHOD_PUT;
cache->rest.delete_tile.method = MAPCACHE_REST_METHOD_DELETE;
cache->rest.multi_set_tile.method = MAPCACHE_REST_METHOD_PUT;
cache->rest.has_tile.method = MAPCACHE_REST_METHOD_HEAD;
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_REST;
cache->cache._tile_delete = _mapcache_cache_rest_delete;
cache->cache._tile_get = _mapcache_cache_rest_get;
cache->cache._tile_exists = _mapcache_cache_rest_has_tile;
cache->cache._tile_set = _mapcache_cache_rest_set;
cache->cache.configuration_post_config = _mapcache_cache_rest_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_rest_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
}
/**
* \brief creates and initializes a mapcache_rest_cache
*/
mapcache_cache* mapcache_cache_rest_create(mapcache_context *ctx)
{
mapcache_cache_rest *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_rest));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate rest cache");
return NULL;
}
mapcache_cache_rest_init(ctx,cache);
cache->provider = MAPCACHE_REST_PROVIDER_NONE;
return (mapcache_cache*)cache;
}
/**
* \brief creates and initializes a mapcache_s3_cache
*/
mapcache_cache* mapcache_cache_s3_create(mapcache_context *ctx)
{
mapcache_cache_s3 *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_s3));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate s3 cache");
return NULL;
}
mapcache_cache_rest_init(ctx,&cache->cache);
cache->cache.provider = MAPCACHE_REST_PROVIDER_S3;
cache->cache.cache.configuration_parse_xml = _mapcache_cache_s3_configuration_parse_xml;
cache->cache.rest.get_tile.add_headers = _mapcache_cache_s3_get_headers_add;
cache->cache.rest.has_tile.add_headers = _mapcache_cache_s3_head_headers_add;
cache->cache.rest.set_tile.add_headers = _mapcache_cache_s3_put_headers_add;
cache->cache.rest.delete_tile.add_headers = _mapcache_cache_s3_delete_headers_add;
return (mapcache_cache*)cache;
}
/**
* \brief creates and initializes a mapcache_azure_cache
*/
mapcache_cache* mapcache_cache_azure_create(mapcache_context *ctx)
{
mapcache_cache_azure *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_azure));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate azure cache");
return NULL;
}
mapcache_cache_rest_init(ctx,&cache->cache);
cache->cache.provider = MAPCACHE_REST_PROVIDER_AZURE;
cache->cache.cache.configuration_parse_xml = _mapcache_cache_azure_configuration_parse_xml;
cache->cache.rest.get_tile.add_headers = _mapcache_cache_azure_get_headers_add;
cache->cache.rest.has_tile.add_headers = _mapcache_cache_azure_head_headers_add;
cache->cache.rest.set_tile.add_headers = _mapcache_cache_azure_put_headers_add;
cache->cache.rest.delete_tile.add_headers = _mapcache_cache_azure_delete_headers_add;
return (mapcache_cache*)cache;
}
/**
* \brief creates and initializes a mapcache_google_cache
*/
mapcache_cache* mapcache_cache_google_create(mapcache_context *ctx)
{
mapcache_cache_google *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_google));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate google cache");
return NULL;
}
mapcache_cache_rest_init(ctx,&cache->cache);
cache->cache.provider = MAPCACHE_REST_PROVIDER_GOOGLE;
cache->cache.cache.configuration_parse_xml = _mapcache_cache_google_configuration_parse_xml;
cache->cache.rest.get_tile.add_headers = _mapcache_cache_google_get_headers_add;
cache->cache.rest.has_tile.add_headers = _mapcache_cache_google_head_headers_add;
cache->cache.rest.set_tile.add_headers = _mapcache_cache_google_put_headers_add;
cache->cache.rest.delete_tile.add_headers = _mapcache_cache_google_delete_headers_add;
return (mapcache_cache*)cache;
}
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_riak.c 0000664 0000000 0000000 00000035351 14653160677 0017126 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: riak cache backend.
* Author: Michael Downey and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2013 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_RIAK
#include
#include
#include
#include
#include
#include
typedef struct mapcache_cache_riak mapcache_cache_riak;
/**\class mapcache_cache_riak
* \brief a mapcache_cache for riak servers
* \implements mapcache_cache
*/
struct mapcache_cache_riak {
mapcache_cache cache;
char *host;
int port;
char *key_template;
char *bucket_template;
};
struct riak_conn_params {
mapcache_cache_riak *cache;
};
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);
if (client == NULL) {
ctx->set_error(ctx,500,"failed to riack_new_client(0)");
return;
}
options.recv_timeout_ms = 2000;
options.send_timeout_ms = 2000;
if (riack_connect(client, cache->host, cache->port, &options) != RIACK_SUCCESS) {
riack_free(client);
ctx->set_error(ctx,500,"failed to riack_connect()");
return;
}
if (riack_ping(client) != RIACK_SUCCESS) {
riack_free(client);
ctx->set_error(ctx,500,"failed to riack_ping()");
return;
}
*conn_ = client;
}
void mapcache_riak_connection_destructor(void *conn_) {
struct RIACK_CLIENT *client = (struct RIACK_CLIENT *)conn_;
riack_free(client);
}
static mapcache_pooled_connection* _riak_get_connection(mapcache_context *ctx, mapcache_cache_riak *cache, mapcache_tile *tile)
{
mapcache_pooled_connection *pc;
struct riak_conn_params params;
params.cache = cache;
pc = mapcache_connection_pool_get_connection(ctx,cache->cache.name,mapcache_riak_connection_constructor,
mapcache_riak_connection_destructor, ¶ms);
return pc;
}
static int _mapcache_cache_riak_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
int error;
RIACK_STRING key,bucket;
struct RIACK_GET_OBJECT obj;
struct RIACK_CLIENT *client;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
key.value = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
key.len = strlen(key.value);
if(strchr(cache->bucket_template,'{')) {
bucket.value = mapcache_util_get_tile_key(ctx, tile, cache->bucket_template, " \r\n\t\f\e\a\b", "#");
} else {
bucket.value = cache->bucket_template;
}
bucket.len = strlen(bucket.value);
pc = _riak_get_connection(ctx, cache, tile);
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
client = pc->connection;
error = riack_get(client, bucket, key, 0, &obj);
if (error != RIACK_SUCCESS) {
mapcache_connection_pool_invalidate_connection(ctx,pc);
ctx->set_error(ctx, 500, "riak: failed to get key %s: %d", key, error);
return MAPCACHE_FALSE;
}
if (obj.object.content_count < 1 || obj.object.content[0].data_len == 0) {
error = MAPCACHE_FALSE;
} else {
error = MAPCACHE_TRUE;
}
riack_free_get_object(client, &obj); // riack_get allocates the returned object so we need to deallocate it.
mapcache_connection_pool_release_connection(ctx,pc);
return error;
}
static void _mapcache_cache_riak_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
int error;
RIACK_STRING key,bucket;
struct RIACK_CLIENT *client;
struct RIACK_DEL_PROPERTIES properties;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
memset(&properties, 0, sizeof(struct RIACK_DEL_PROPERTIES));
key.value = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
GC_CHECK_ERROR(ctx);
key.len = strlen(key.value);
if(strchr(cache->bucket_template,'{')) {
bucket.value = mapcache_util_get_tile_key(ctx, tile, cache->bucket_template, " \r\n\t\f\e\a\b", "#");
} else {
bucket.value = cache->bucket_template;
}
bucket.len = strlen(bucket.value);
pc = _riak_get_connection(ctx, cache, tile);
GC_CHECK_ERROR(ctx);
client = pc->connection;
properties.rw_use = 1;
properties.rw = (4294967295 - 3); // Special value meaning "ALL"
error = riack_delete(client, bucket, key, &properties);
mapcache_connection_pool_release_connection(ctx,pc);
if (error != RIACK_SUCCESS) {
ctx->set_error(ctx, 500, "riak: failed to delete key %s: %d", key, error);
}
}
/**
* \brief get content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored on the riak server
* \private \memberof mapcache_cache_riak
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_riak_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
int error;
RIACK_STRING key,bucket;
struct RIACK_GET_OBJECT obj;
struct RIACK_GET_PROPERTIES properties;
struct RIACK_CLIENT *client;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
memset(&properties, 0, sizeof(struct RIACK_GET_PROPERTIES));
//Use Buckets defaults instead of setting the read/write attributes
/*
properties.r_use = 1;
properties.r = 1;
*/
key.value = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
key.len = strlen(key.value);
if(strchr(cache->bucket_template,'{')) {
bucket.value = mapcache_util_get_tile_key(ctx, tile, cache->bucket_template, " \r\n\t\f\e\a\b", "#");
} else {
bucket.value = cache->bucket_template;
}
bucket.len = strlen(bucket.value);
pc = _riak_get_connection(ctx, cache, tile);
if (GC_HAS_ERROR(ctx)) {
return MAPCACHE_FAILURE;
}
client = pc->connection;
error = riack_get(client, bucket, key, &properties, &obj);
if (error != RIACK_SUCCESS)
{
mapcache_connection_pool_invalidate_connection(ctx,pc);
ctx->set_error(ctx, 500, "Failed to get tile %s from cache %s due to error %d", key.value, cache->cache.name, error);
return MAPCACHE_FAILURE;
}
// Check if tile exists. If it doesn't we need to return CACHE_MISS or things go wrong.
// Mapcache doesn't appear to use the has_tile function and uses _get instead so we need
// to do this sort of test here instead of erroring.
if (obj.object.content_count < 1 || obj.object.content[0].data_len == 0) {
riack_free_get_object(client, &obj); // Need to free the object here as well.
mapcache_connection_pool_release_connection(ctx,pc);
return MAPCACHE_CACHE_MISS;
}
// Copy the data into the buffer
tile->encoded_data = mapcache_buffer_create(0, ctx->pool);
mapcache_buffer_append(tile->encoded_data, obj.object.content[0].data_len, obj.object.content[0].data);
riack_free_get_object(client, &obj); // riack_get allocates the returned object so we need to deallocate it.
mapcache_connection_pool_release_connection(ctx,pc);
return MAPCACHE_SUCCESS;
}
/**
* \brief push tile data to riak
*
* writes the content of mapcache_tile::data to the configured riak instance(s)
* \private \memberof mapcache_cache_riak
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_riak_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) {
char *key,*content_type;
int error;
struct RIACK_OBJECT object;
struct RIACK_CONTENT content;
struct RIACK_PUT_PROPERTIES properties;
struct RIACK_CLIENT *client;
RIACK_STRING bucket;
mapcache_pooled_connection *pc;
mapcache_cache_riak *cache = (mapcache_cache_riak*)pcache;
memset(&content, 0, sizeof(struct RIACK_CONTENT));
memset(&object, 0, sizeof(struct RIACK_OBJECT));
memset(&properties, 0, sizeof(struct RIACK_PUT_PROPERTIES));
//Use Buckets defaults instead of setting the read/write attributes
/*
properties.w_use = 1;
properties.w = 1;
properties.dw_use = 1;
properties.dw = 0;*/
key = mapcache_util_get_tile_key(ctx, tile, cache->key_template, " \r\n\t\f\e\a\b", "#");
GC_CHECK_ERROR(ctx);
if(strchr(cache->bucket_template,'{')) {
bucket.value = mapcache_util_get_tile_key(ctx, tile, cache->bucket_template, " \r\n\t\f\e\a\b", "#");
} else {
bucket.value = cache->bucket_template;
}
bucket.len = strlen(bucket.value);
if (!tile->encoded_data) {
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);
client = pc->connection;
// Set up the riak object to put. Need to do this after we get the client connection
object.bucket = bucket;
object.key.value = key;
object.key.len = strlen(key);
object.vclock.len = 0;
object.content_count = 1;
object.content = &content;
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;
error = riack_put(client, object, 0, &properties);
if (error != RIACK_SUCCESS)
mapcache_connection_pool_invalidate_connection(ctx,pc);
else
mapcache_connection_pool_release_connection(ctx,pc);
if (error != RIACK_SUCCESS)
{
ctx->set_error(ctx, 500, "failed to store tile %s to cache %s due to error %d.", key, cache->cache.name, error);
}
}
/**
* \private \memberof mapcache_cache_riak
*/
static void _mapcache_cache_riak_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) {
ezxml_t cur_node,xhost,xport,xbucket,xkey;
mapcache_cache_riak *dcache = (mapcache_cache_riak*)cache;
int servercount = 0;
for (cur_node = ezxml_child(node,"server"); cur_node; cur_node = cur_node->next) {
servercount++;
}
if (!servercount) {
ctx->set_error(ctx, 400, "riak cache %s has no s configured", cache->name);
return;
}
if (servercount > 1) {
ctx->set_error(ctx, 400, "riak cache %s has more than 1 server configured", cache->name);
return;
}
cur_node = ezxml_child(node, "server");
xhost = ezxml_child(cur_node, "host"); /* Host should contain just server */
xport = ezxml_child(cur_node, "port");
xbucket = ezxml_child(cur_node, "bucket");
xkey = ezxml_child(cur_node, "key");
if (!xhost || !xhost->txt || ! *xhost->txt) {
ctx->set_error(ctx, 400, "cache %s: with no ", cache->name);
return;
} else {
dcache->host = apr_pstrdup(ctx->pool, xhost->txt);
}
if (!xport || !xport->txt || ! *xport->txt) {
ctx->set_error(ctx, 400, "cache %s: with no ", cache->name);
return;
} else {
dcache->port = atoi(xport->txt);
}
if (!xbucket || !xbucket->txt || ! *xbucket->txt) {
ctx->set_error(ctx, 400, "cache %s: with no ", cache->name);
return;
} else {
dcache->bucket_template = apr_pstrdup(ctx->pool, xbucket->txt);
}
if(xkey && xkey->txt && *xkey->txt) {
dcache->key_template = apr_pstrdup(ctx->pool, xkey->txt);
}
}
/**
* \private \memberof mapcache_cache_riak
*/
static void _mapcache_cache_riak_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache, mapcache_cfg *cfg) {
riack_init();
}
/**
* \brief creates and initializes a mapcache_riak_cache
*/
mapcache_cache* mapcache_cache_riak_create(mapcache_context *ctx) {
mapcache_cache_riak *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_riak));
if (!cache) {
ctx->set_error(ctx, 500, "failed to allocate riak cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool, 3);
cache->cache.type = MAPCACHE_CACHE_RIAK;
cache->cache._tile_get = _mapcache_cache_riak_get;
cache->cache._tile_exists = _mapcache_cache_riak_has_tile;
cache->cache._tile_set = _mapcache_cache_riak_set;
cache->cache._tile_delete = _mapcache_cache_riak_delete;
cache->cache.configuration_parse_xml = _mapcache_cache_riak_configuration_parse_xml;
cache->cache.configuration_post_config = _mapcache_cache_riak_configuration_post_config;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->host = NULL;
cache->port = 8087; // Default RIAK port used for protobuf
cache->bucket_template = NULL;
cache->key_template = NULL;
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_riak_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"RIAK support not compiled in this version");
return NULL;
}
#endif
mapcache-rel-1-14-1/lib/cache_sqlite.c 0000664 0000000 0000000 00000131100 14653160677 0017466 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: sqlite cache backend
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_SQLITE
#include
#include
#include
#include
#include
#include
#ifdef APR_HAS_THREADS
#include
#endif
#ifndef _WIN32
#include
#endif
#include
/**\class mapcache_cache_sqlite
* \brief a mapcache_cache on a filesytem
* \implements mapcache_cache
*/
typedef struct mapcache_cache_sqlite mapcache_cache_sqlite;
typedef struct mapcache_cache_sqlite_stmt mapcache_cache_sqlite_stmt;
struct mapcache_cache_sqlite_stmt {
char *sql;
};
struct sqlite_conn;
struct mapcache_cache_sqlite {
mapcache_cache cache;
char *dbfile;
mapcache_cache_sqlite_stmt create_stmt;
mapcache_cache_sqlite_stmt exists_stmt;
mapcache_cache_sqlite_stmt get_stmt;
mapcache_cache_sqlite_stmt set_stmt;
mapcache_cache_sqlite_stmt delete_stmt;
apr_table_t *pragmas;
void (*bind_stmt)(mapcache_context *ctx, void *stmt, mapcache_cache_sqlite *cache, mapcache_tile *tile);
int n_prepared_statements;
int detect_blank;
char *x_fmt,*y_fmt,*z_fmt,*inv_x_fmt,*inv_y_fmt,*div_x_fmt,*div_y_fmt,*inv_div_x_fmt,*inv_div_y_fmt,
*top_fmt,*top_x_fmt,*top_y_fmt,*inv_top_x_fmt,*inv_top_y_fmt;
int count_x, count_y;
int top;
int allow_path_in_dim;
};
struct sqlite_conn_params {
mapcache_cache_sqlite *cache;
char *dbfile;
int readonly;
};
struct sqlite_conn {
sqlite3 *handle;
int nstatements;
sqlite3_stmt **prepared_statements;
};
#define SQLITE_CONN(pooled_connection) ((struct sqlite_conn*)((pooled_connection)->connection))
#define HAS_TILE_STMT_IDX 0
#define GET_TILE_STMT_IDX 1
#define SQLITE_SET_TILE_STMT_IDX 2
#define SQLITE_DEL_TILE_STMT_IDX 3
#define MBTILES_SET_EMPTY_TILE_STMT1_IDX 2
#define MBTILES_SET_EMPTY_TILE_STMT2_IDX 3
#define MBTILES_SET_TILE_STMT1_IDX 4
#define MBTILES_SET_TILE_STMT2_IDX 5
#define MBTILES_DEL_TILE_SELECT_STMT_IDX 6
#define MBTILES_DEL_TILE_STMT1_IDX 7
#define MBTILES_DEL_TILE_STMT2_IDX 8
static void _mapcache_cache_sqlite_filename_for_tile(mapcache_context *ctx, mapcache_cache_sqlite *dcache, mapcache_tile *tile, char **path);
static void _sqlite_set_pragmas(mapcache_context *ctx, mapcache_cache_sqlite* cache, struct sqlite_conn *conn)
{
if (cache->pragmas && !apr_is_empty_table(cache->pragmas)) {
const apr_array_header_t *elts = apr_table_elts(cache->pragmas);
/* FIXME dynamically allocate this string */
int i,ret;
char *pragma_stmt;
for (i = 0; i < elts->nelts; i++) {
apr_table_entry_t entry = APR_ARRAY_IDX(elts, i, apr_table_entry_t);
pragma_stmt = apr_psprintf(ctx->pool,"PRAGMA %s=%s",entry.key,entry.val);
do {
ret = sqlite3_exec(conn->handle, pragma_stmt, 0, 0, NULL);
if (ret != SQLITE_OK && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
break;
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if (ret != SQLITE_OK) {
ctx->set_error(ctx, 500, "failed to execute pragma statement %s",pragma_stmt);
return;
}
}
}
return;
}
static void mapcache_sqlite_release_conn(mapcache_context *ctx, mapcache_pooled_connection *conn) {
mapcache_connection_pool_release_connection(ctx,conn);
}
void mapcache_sqlite_connection_constructor(mapcache_context *ctx, void **conn_, void *params)
{
int ret;
int flags;
struct sqlite_conn_params *sq_params = (struct sqlite_conn_params*)params;
struct sqlite_conn *conn = calloc(1, sizeof (struct sqlite_conn));
*conn_ = conn;
if(sq_params->readonly) {
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) {
ctx->set_error(ctx,500,"sqlite backend failed to open db %s: %s", sq_params->dbfile, sqlite3_errmsg(conn->handle));
return;
}
sqlite3_busy_timeout(conn->handle, 300000);
do {
ret = sqlite3_exec(conn->handle, sq_params->cache->create_stmt.sql, 0, 0, NULL);
if (ret != SQLITE_OK && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
break;
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if (ret != SQLITE_OK) {
ctx->set_error(ctx,500, "sqlite backend failed to create db schema on %s: %s", sq_params->dbfile, sqlite3_errmsg(conn->handle));
sqlite3_close(conn->handle);
return;
}
_sqlite_set_pragmas(ctx, sq_params->cache, conn);
if(GC_HAS_ERROR(ctx)) {
sqlite3_close(conn->handle);
return;
}
conn->prepared_statements = calloc(sq_params->cache->n_prepared_statements,sizeof(sqlite3_stmt*));
conn->nstatements = sq_params->cache->n_prepared_statements;
}
void mapcache_sqlite_connection_destructor(void *conn_)
{
struct sqlite_conn *conn = (struct sqlite_conn*) conn_;
int i;
for(i=0; instatements; i++) {
if(conn->prepared_statements[i]) {
sqlite3_finalize(conn->prepared_statements[i]);
}
}
free(conn->prepared_statements);
sqlite3_close(conn->handle);
}
static mapcache_pooled_connection* mapcache_sqlite_get_conn(mapcache_context *ctx, mapcache_cache_sqlite *cache, mapcache_tile *tile, int readonly) {
struct sqlite_conn_params params;
mapcache_pooled_connection *pc;
char *key;
_mapcache_cache_sqlite_filename_for_tile(ctx,cache,tile,¶ms.dbfile);
params.cache = cache;
params.readonly = readonly;
if(!strstr(cache->dbfile,"{")) {
key = apr_pstrcat(ctx->pool,readonly?"ro_":"rw_",cache->cache.name,NULL);
} else {
key = apr_pstrcat(ctx->pool,readonly?"ro_":"rw_",params.dbfile,NULL);
}
pc = mapcache_connection_pool_get_connection(ctx,key,mapcache_sqlite_connection_constructor,mapcache_sqlite_connection_destructor,¶ms);
return pc;
}
/**
* \brief return sqlite db filename for given tile
*
* \param tile the tile to get the key from
* \param path pointer to a char* that will contain the filename
* \param r
* \private \memberof mapcache_cache_sqlite
*/
static void _mapcache_cache_sqlite_filename_for_tile(mapcache_context *ctx, mapcache_cache_sqlite *dcache, mapcache_tile *tile, char **path)
{
*path = dcache->dbfile;
if(strstr(*path,"{")) {
/*
* generic template substitutions
*/
if(strstr(*path,"{tileset}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{tileset}",
tile->tileset->name);
if(strstr(*path,"{grid}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{grid}",
tile->grid_link->grid->name);
if(tile->dimensions && strstr(*path,"{dim")) {
char *dimstring="";
int i = tile->dimensions->nelts;
while(i--) {
mapcache_requested_dimension *entry = APR_ARRAY_IDX(tile->dimensions,i,mapcache_requested_dimension*);
mapcache_dimension_type dimtype = entry->dimension->type;
const char *dimval;
char *single_dim;
if (dcache->allow_path_in_dim
&& (dimtype == MAPCACHE_DIMENSION_POSTGRESQL
|| dimtype == MAPCACHE_DIMENSION_SQLITE
|| dimtype == MAPCACHE_DIMENSION_ELASTICSEARCH))
{
// Only if paths are allowed in dimension values and dimension is a second level type
// Forbid "../" in the dimension value
dimval = mapcache_util_str_replace_all(ctx->pool, entry->cached_value, "../", "#");
}
else
{
// If paths are not allowed in dimension values or if dimension is not a second level type
// Forbid '.' and '/' in the dimension value
dimval = mapcache_util_str_sanitize(ctx->pool,entry->cached_value,"/.",'#');
}
single_dim = apr_pstrcat(ctx->pool,"{dim:",entry->dimension->name,"}",NULL);
dimstring = apr_pstrcat(ctx->pool,dimstring,"#",dimval,NULL);
if(strstr(*path,single_dim)) {
*path = mapcache_util_str_replace(ctx->pool,*path, single_dim, dimval);
}
}
*path = mapcache_util_str_replace(ctx->pool,*path, "{dim}", dimstring);
}
while(strstr(*path,"{z}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{z}",
apr_psprintf(ctx->pool,dcache->z_fmt,tile->z));
if(dcache->count_x > 0) {
while(strstr(*path,"{div_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{div_x}",
apr_psprintf(ctx->pool,dcache->div_x_fmt,tile->x/dcache->count_x));
while(strstr(*path,"{inv_div_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_div_x}",
apr_psprintf(ctx->pool,dcache->inv_div_x_fmt,(tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1)/dcache->count_x));
while(strstr(*path,"{x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{x}",
apr_psprintf(ctx->pool,dcache->x_fmt,tile->x/dcache->count_x*dcache->count_x));
while(strstr(*path,"{inv_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_x}",
apr_psprintf(ctx->pool,dcache->inv_x_fmt,(tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1)/dcache->count_x*dcache->count_x));
}
if(dcache->count_y > 0) {
while(strstr(*path,"{div_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{div_y}",
apr_psprintf(ctx->pool,dcache->div_y_fmt,tile->y/dcache->count_y));
while(strstr(*path,"{inv_div_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_div_y}",
apr_psprintf(ctx->pool,dcache->inv_div_y_fmt,(tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1)/dcache->count_y));
while(strstr(*path,"{y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{y}",
apr_psprintf(ctx->pool,dcache->y_fmt,tile->y/dcache->count_y*dcache->count_y));
while(strstr(*path,"{inv_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_y}",
apr_psprintf(ctx->pool,dcache->inv_y_fmt,(tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1)/dcache->count_y*dcache->count_y));
}
if (dcache->top > 0) {
while(strstr(*path,"{top}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{top}",
apr_psprintf(ctx->pool,dcache->top_fmt,dcache->top));
while(strstr(*path,"{top_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{top_x}",
apr_psprintf(ctx->pool,dcache->top_x_fmt,
tile->x * tile->grid_link->grid->levels[dcache->top]->maxx
/ tile->grid_link->grid->levels[tile->z]->maxx));
while(strstr(*path,"{top_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{top_y}",
apr_psprintf(ctx->pool,dcache->top_y_fmt,
tile->y * tile->grid_link->grid->levels[dcache->top]->maxy
/ tile->grid_link->grid->levels[tile->z]->maxy));
while(strstr(*path,"{inv_top_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_top_x}",
apr_psprintf(ctx->pool,dcache->inv_top_x_fmt,
tile->grid_link->grid->levels[dcache->top]->maxx - 1
- tile->x * tile->grid_link->grid->levels[dcache->top]->maxx
/ tile->grid_link->grid->levels[tile->z]->maxx));
while(strstr(*path,"{inv_top_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_top_y}",
apr_psprintf(ctx->pool,dcache->inv_top_y_fmt,
tile->grid_link->grid->levels[dcache->top]->maxy - 1
- tile->y * tile->grid_link->grid->levels[dcache->top]->maxy
/ tile->grid_link->grid->levels[tile->z]->maxy));
}
}
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
/**
* \brief apply appropriate tile properties to the sqlite statement */
static void _bind_sqlite_params(mapcache_context *ctx, void *vstmt, mapcache_cache_sqlite *cache, mapcache_tile *tile)
{
sqlite3_stmt *stmt = vstmt;
int paramidx;
/* tile->x */
paramidx = sqlite3_bind_parameter_index(stmt, ":x");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->x);
paramidx = sqlite3_bind_parameter_index(stmt, ":inv_x");
if (paramidx)
sqlite3_bind_int(stmt, paramidx, tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1);
/* tile->y */
paramidx = sqlite3_bind_parameter_index(stmt, ":y");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->y);
paramidx = sqlite3_bind_parameter_index(stmt, ":inv_y");
if (paramidx)
sqlite3_bind_int(stmt, paramidx, tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1);
/* tile->z */
paramidx = sqlite3_bind_parameter_index(stmt, ":z");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->z);
/* eventual dimensions */
paramidx = sqlite3_bind_parameter_index(stmt, ":dim");
if (paramidx) {
if (tile->dimensions) {
char *dim = mapcache_util_get_tile_dimkey(ctx, tile, NULL, NULL);
sqlite3_bind_text(stmt, paramidx, dim, -1, SQLITE_STATIC);
} else {
sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC);
}
}
/* grid */
paramidx = sqlite3_bind_parameter_index(stmt, ":grid");
if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->grid_link->grid->name, -1, SQLITE_STATIC);
/* tileset */
paramidx = sqlite3_bind_parameter_index(stmt, ":tileset");
if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->tileset->name, -1, SQLITE_STATIC);
/* tile blob data */
paramidx = sqlite3_bind_parameter_index(stmt, ":data");
if (paramidx) {
int written = 0;
if(cache->detect_blank) {
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
char *buf = apr_palloc(ctx->pool, 5* sizeof(char));
buf[0] = '#';
memcpy(buf+1,tile->raw_image->data,4);
written = 1;
sqlite3_bind_blob(stmt, paramidx, buf, 5, SQLITE_STATIC);
}
}
if(!written) {
if (!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
if (tile->encoded_data && tile->encoded_data->size) {
sqlite3_bind_blob(stmt, paramidx, tile->encoded_data->buf, tile->encoded_data->size, SQLITE_STATIC);
} else {
sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC);
}
}
}
}
static void _bind_mbtiles_params(mapcache_context *ctx, void *vstmt, mapcache_cache_sqlite *cache, mapcache_tile *tile)
{
sqlite3_stmt *stmt = vstmt;
int paramidx;
paramidx = sqlite3_bind_parameter_index(stmt, ":x");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->x);
/* tile->y */
paramidx = sqlite3_bind_parameter_index(stmt, ":y");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->y);
/* tile->y */
paramidx = sqlite3_bind_parameter_index(stmt, ":z");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->z);
/* mbtiles foreign key */
paramidx = sqlite3_bind_parameter_index(stmt, ":key");
if (paramidx) {
char *key = apr_psprintf(ctx->pool,"%d-%d-%d",tile->x,tile->y,tile->z);
sqlite3_bind_text(stmt, paramidx, key, -1, SQLITE_STATIC);
}
paramidx = sqlite3_bind_parameter_index(stmt, ":color");
if (paramidx) {
char *key;
assert(tile->raw_image);
key = apr_psprintf(ctx->pool,"#%02x%02x%02x%02x",
tile->raw_image->data[0],
tile->raw_image->data[1],
tile->raw_image->data[2],
tile->raw_image->data[3]);
sqlite3_bind_text(stmt, paramidx, key, -1, SQLITE_STATIC);
}
/* tile blob data */
paramidx = sqlite3_bind_parameter_index(stmt, ":data");
if (paramidx) {
if (!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
if (tile->encoded_data && tile->encoded_data->size) {
sqlite3_bind_blob(stmt, paramidx, tile->encoded_data->buf, tile->encoded_data->size, SQLITE_STATIC);
} else {
sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC);
}
}
}
static int _mapcache_cache_sqlite_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) pcache;
mapcache_pooled_connection *pc;
struct sqlite_conn *conn;
sqlite3_stmt *stmt;
int ret;
pc = mapcache_sqlite_get_conn(ctx,cache,tile,1);
if (GC_HAS_ERROR(ctx)) {
if(pc) mapcache_sqlite_release_conn(ctx, pc);
if(!tile->tileset->read_only && tile->tileset->source) {
/* not an error in this case, as the db file may not have been created yet */
ctx->clear_errors(ctx);
}
return MAPCACHE_FALSE;
}
conn = SQLITE_CONN(pc);
stmt = conn->prepared_statements[HAS_TILE_STMT_IDX];
if(!stmt) {
sqlite3_prepare(conn->handle, cache->exists_stmt.sql, -1, &conn->prepared_statements[HAS_TILE_STMT_IDX], NULL);
stmt = conn->prepared_statements[HAS_TILE_STMT_IDX];
}
cache->bind_stmt(ctx, stmt, cache, tile);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on has_tile: %s", sqlite3_errmsg(conn->handle));
}
if (ret == SQLITE_DONE) {
ret = MAPCACHE_FALSE;
} else if (ret == SQLITE_ROW) {
ret = MAPCACHE_TRUE;
}
sqlite3_reset(stmt);
mapcache_sqlite_release_conn(ctx, pc);
return ret;
}
static void _mapcache_cache_sqlite_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) pcache;
mapcache_pooled_connection *pc;
struct sqlite_conn *conn;
sqlite3_stmt *stmt;
int ret;
pc = mapcache_sqlite_get_conn(ctx,cache,tile,0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
stmt = conn->prepared_statements[SQLITE_DEL_TILE_STMT_IDX];
if(!stmt) {
sqlite3_prepare(conn->handle, cache->delete_stmt.sql, -1, &conn->prepared_statements[SQLITE_DEL_TILE_STMT_IDX], NULL);
stmt = conn->prepared_statements[SQLITE_DEL_TILE_STMT_IDX];
}
cache->bind_stmt(ctx, stmt, cache, tile);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on delete: %s", sqlite3_errmsg(conn->handle));
}
sqlite3_reset(stmt);
mapcache_sqlite_release_conn(ctx, pc);
}
static void _mapcache_cache_mbtiles_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) pcache;
mapcache_pooled_connection *pc;
struct sqlite_conn *conn;
sqlite3_stmt *stmt1,*stmt2,*stmt3;
int ret;
const char *tile_id;
size_t tile_id_size;
pc = mapcache_sqlite_get_conn(ctx,cache,tile,0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX];
stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX];
stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle, "select tile_id from map where tile_col=:x and tile_row=:y and zoom_level=:z",-1,&conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX], NULL);
sqlite3_prepare(conn->handle, "delete from map where tile_col=:x and tile_row=:y and zoom_level=:z", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle, "delete from images where tile_id=:foobar", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX];
stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX];
stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX];
}
/* first extract tile_id from the tile we will delete. We need this because we do not know
* if the tile is empty or not.
* If it is empty, we will not delete the image blob data from the images table */
cache->bind_stmt(ctx, stmt1, cache, tile);
do {
ret = sqlite3_step(stmt1);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 1: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
mapcache_sqlite_release_conn(ctx, pc);
return;
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if (ret == SQLITE_DONE) { /* tile does not exist, ignore */
sqlite3_reset(stmt1);
mapcache_sqlite_release_conn(ctx, pc);
return;
} else {
tile_id = (const char*) sqlite3_column_text(stmt1, 0);
tile_id_size = sqlite3_column_bytes(stmt1, 0);
}
/* delete the tile from the "map" table */
cache->bind_stmt(ctx,stmt2, cache, tile);
ret = sqlite3_step(stmt2);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 2: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
mapcache_sqlite_release_conn(ctx, pc);
return;
}
if(tile_id[0] != '#') {
/* the tile isn't empty, we must also delete from the images table */
int paramidx = sqlite3_bind_parameter_index(stmt3, ":foobar");
if (paramidx) {
sqlite3_bind_text(stmt3, paramidx, tile_id, tile_id_size, SQLITE_STATIC);
}
ret = sqlite3_step(stmt3);
if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 3: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
sqlite3_reset(stmt3);
mapcache_sqlite_release_conn(ctx, pc);
return;
}
}
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
sqlite3_reset(stmt3);
mapcache_sqlite_release_conn(ctx, pc);
}
static void _single_mbtile_set(mapcache_context *ctx, mapcache_cache_sqlite *cache, mapcache_tile *tile, struct sqlite_conn *conn)
{
sqlite3_stmt *stmt1,*stmt2;
int ret;
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
stmt1 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle,
"insert or ignore into images(tile_id,tile_data) values (:color,:data);",
-1, &conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle,
"insert or replace into map(tile_column,tile_row,zoom_level,tile_id) values (:x,:y,:z,:color);",
-1, &conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_EMPTY_TILE_STMT2_IDX];
}
cache->bind_stmt(ctx, stmt1, cache, tile);
cache->bind_stmt(ctx, stmt2, cache, tile);
} else {
stmt1 = conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX];
if(!stmt1) {
sqlite3_prepare(conn->handle,
"insert or replace into images(tile_id,tile_data) values (:key,:data);",
-1, &conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX], NULL);
sqlite3_prepare(conn->handle,
"insert or replace into map(tile_column,tile_row,zoom_level,tile_id) values (:x,:y,:z,:key);",
-1, &conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX], NULL);
stmt1 = conn->prepared_statements[MBTILES_SET_TILE_STMT1_IDX];
stmt2 = conn->prepared_statements[MBTILES_SET_TILE_STMT2_IDX];
}
cache->bind_stmt(ctx, stmt1, cache, tile);
cache->bind_stmt(ctx, stmt2, cache, tile);
}
do {
ret = sqlite3_step(stmt1);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "mbtiles backend failed on image set: %s (%d)", sqlite3_errmsg(conn->handle), ret);
break;
}
if (ret == SQLITE_BUSY) {
sqlite3_reset(stmt1);
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if(ret == SQLITE_DONE) {
do {
ret = sqlite3_step(stmt2);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "mbtiles backend failed on map set: %s (%d)", sqlite3_errmsg(conn->handle), ret);
break;
}
if (ret == SQLITE_BUSY) {
sqlite3_reset(stmt2);
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
}
sqlite3_reset(stmt1);
sqlite3_reset(stmt2);
}
static int _mapcache_cache_sqlite_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) pcache;
struct sqlite_conn *conn;
sqlite3_stmt *stmt;
int ret;
mapcache_pooled_connection *pc = mapcache_sqlite_get_conn(ctx,cache,tile,1);
if (GC_HAS_ERROR(ctx)) {
if(tile->tileset->read_only || !tile->tileset->source) {
mapcache_sqlite_release_conn(ctx, pc);
return MAPCACHE_FAILURE;
} else {
/* not an error in this case, as the db file may not have been created yet */
ctx->clear_errors(ctx);
mapcache_sqlite_release_conn(ctx, pc);
return MAPCACHE_CACHE_MISS;
}
}
conn = SQLITE_CONN(pc);
stmt = conn->prepared_statements[GET_TILE_STMT_IDX];
if(!stmt) {
sqlite3_prepare(conn->handle, cache->get_stmt.sql, -1, &conn->prepared_statements[GET_TILE_STMT_IDX], NULL);
stmt = conn->prepared_statements[GET_TILE_STMT_IDX];
}
cache->bind_stmt(ctx, stmt, cache, tile);
do {
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "sqlite backend failed on get: %s", sqlite3_errmsg(conn->handle));
sqlite3_reset(stmt);
mapcache_sqlite_release_conn(ctx, pc);
return MAPCACHE_FAILURE;
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
if (ret == SQLITE_DONE) {
sqlite3_reset(stmt);
mapcache_sqlite_release_conn(ctx, pc);
return MAPCACHE_CACHE_MISS;
} else {
const void *blob = sqlite3_column_blob(stmt, 0);
int size = sqlite3_column_bytes(stmt, 0);
if(size>0 && ((char*)blob)[0] == '#') {
tile->encoded_data = mapcache_empty_png_decode(ctx,tile->grid_link->grid->tile_sx, tile->grid_link->grid->tile_sy ,blob,&tile->nodata);
} else {
tile->encoded_data = mapcache_buffer_create(size, ctx->pool);
memcpy(tile->encoded_data->buf, blob, size);
tile->encoded_data->size = size;
}
if (sqlite3_column_count(stmt) > 1) {
time_t mtime = sqlite3_column_int64(stmt, 1);
apr_time_ansi_put(&(tile->mtime), mtime);
}
sqlite3_reset(stmt);
mapcache_sqlite_release_conn(ctx, pc);
return MAPCACHE_SUCCESS;
}
}
static void _single_sqlitetile_set(mapcache_context *ctx, mapcache_cache_sqlite *cache, mapcache_tile *tile, struct sqlite_conn *conn)
{
sqlite3_stmt *stmt = conn->prepared_statements[SQLITE_SET_TILE_STMT_IDX];
int ret;
if(!stmt) {
sqlite3_prepare(conn->handle, cache->set_stmt.sql, -1, &conn->prepared_statements[SQLITE_SET_TILE_STMT_IDX], NULL);
stmt = conn->prepared_statements[SQLITE_SET_TILE_STMT_IDX];
}
cache->bind_stmt(ctx, stmt, cache, tile);
do {
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) {
ctx->set_error(ctx, 500, "sqlite backend failed on set: %s (%d)", sqlite3_errmsg(conn->handle), ret);
break;
}
if (ret == SQLITE_BUSY) {
sqlite3_reset(stmt);
}
} while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED);
sqlite3_reset(stmt);
}
static void _mapcache_cache_sqlite_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)pcache;
struct sqlite_conn *conn;
mapcache_pooled_connection *pc = mapcache_sqlite_get_conn(ctx,cache,tile,0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
sqlite3_exec(conn->handle, "BEGIN TRANSACTION", 0, 0, 0);
_single_sqlitetile_set(ctx,cache, tile,conn);
if (GC_HAS_ERROR(ctx)) {
sqlite3_exec(conn->handle, "ROLLBACK TRANSACTION", 0, 0, 0);
} else {
sqlite3_exec(conn->handle, "END TRANSACTION", 0, 0, 0);
}
mapcache_sqlite_release_conn(ctx, pc);
}
static void _mapcache_cache_sqlite_multi_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)pcache;
int i;
struct sqlite_conn *conn;
mapcache_pooled_connection *pc = mapcache_sqlite_get_conn(ctx,cache,&tiles[0],0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
sqlite3_exec(conn->handle, "BEGIN TRANSACTION", 0, 0, 0);
for (i = 0; i < ntiles; i++) {
mapcache_tile *tile = &tiles[i];
_single_sqlitetile_set(ctx,cache, tile,conn);
if(GC_HAS_ERROR(ctx)) break;
}
if (GC_HAS_ERROR(ctx)) {
sqlite3_exec(conn->handle, "ROLLBACK TRANSACTION", 0, 0, 0);
} else {
sqlite3_exec(conn->handle, "END TRANSACTION", 0, 0, 0);
}
mapcache_sqlite_release_conn(ctx, pc);
}
static void _mapcache_cache_mbtiles_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)pcache;
struct sqlite_conn *conn;
mapcache_pooled_connection *pc = mapcache_sqlite_get_conn(ctx,cache,tile,0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
if(GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
}
sqlite3_exec(conn->handle, "BEGIN TRANSACTION", 0, 0, 0);
_single_mbtile_set(ctx, cache, tile,conn);
if (GC_HAS_ERROR(ctx)) {
sqlite3_exec(conn->handle, "ROLLBACK TRANSACTION", 0, 0, 0);
} else {
sqlite3_exec(conn->handle, "END TRANSACTION", 0, 0, 0);
}
mapcache_sqlite_release_conn(ctx, pc);
}
static void _mapcache_cache_mbtiles_multi_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tiles, int ntiles)
{
int i;
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)pcache;
mapcache_pooled_connection *pc;
struct sqlite_conn *conn;
/* decode/encode image data before going into the sqlite write lock */
for (i = 0; i < ntiles; i++) {
mapcache_tile *tile = &tiles[i];
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
/* only encode to image format if tile is not blank */
if (mapcache_image_blank_color(tile->raw_image) != MAPCACHE_TRUE && !tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
}
pc = mapcache_sqlite_get_conn(ctx,cache,&tiles[0],0);
if (GC_HAS_ERROR(ctx)) {
mapcache_sqlite_release_conn(ctx, pc);
return;
}
conn = SQLITE_CONN(pc);
sqlite3_exec(conn->handle, "BEGIN TRANSACTION", 0, 0, 0);
for (i = 0; i < ntiles; i++) {
mapcache_tile *tile = &tiles[i];
_single_mbtile_set(ctx,cache,tile,conn);
if(GC_HAS_ERROR(ctx)) break;
}
if (GC_HAS_ERROR(ctx)) {
sqlite3_exec(conn->handle, "ROLLBACK TRANSACTION", 0, 0, 0);
} else {
sqlite3_exec(conn->handle, "END TRANSACTION", 0, 0, 0);
}
mapcache_sqlite_release_conn(ctx, pc);
}
static void _mapcache_cache_sqlite_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *pcache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_sqlite *cache;
char *attr;
sqlite3_initialize();
sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
cache = (mapcache_cache_sqlite*) pcache;
if ((cur_node = ezxml_child(node, "base")) != NULL) {
ctx->set_error(ctx, 500, "sqlite config not supported anymore, use ");
return;
}
if ((cur_node = ezxml_child(node, "dbname_template")) != NULL) {
ctx->set_error(ctx, 500, "sqlite config not supported anymore, use a \"multi-sqlite3\" cache type");
return;
}
cache->allow_path_in_dim = 0;
attr = (char*)ezxml_attr(node,"allow_path_in_dim");
if(attr && *attr && !strcmp(attr,"yes")) {
cache->allow_path_in_dim = 1;
}
if ((cur_node = ezxml_child(node, "dbfile")) != NULL) {
char *fmt;
cache->dbfile = apr_pstrdup(ctx->pool, cur_node->txt);
fmt = (char*)ezxml_attr(cur_node,"x_fmt");
if(fmt && *fmt) {
cache->x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"y_fmt");
if(fmt && *fmt) {
cache->y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"z_fmt");
if(fmt && *fmt) {
cache->z_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_x_fmt");
if(fmt && *fmt) {
cache->inv_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_y_fmt");
if(fmt && *fmt) {
cache->inv_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"div_x_fmt");
if(fmt && *fmt) {
cache->div_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"div_y_fmt");
if(fmt && *fmt) {
cache->div_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_div_x_fmt");
if(fmt && *fmt) {
cache->inv_div_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_div_y_fmt");
if(fmt && *fmt) {
cache->inv_div_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"top_fmt");
if(fmt && *fmt) {
cache->top_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"top_x_fmt");
if(fmt && *fmt) {
cache->top_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"top_y_fmt");
if(fmt && *fmt) {
cache->top_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_top_x_fmt");
if(fmt && *fmt) {
cache->inv_top_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_top_y_fmt");
if(fmt && *fmt) {
cache->inv_top_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
}
cache->detect_blank = 0;
if ((cur_node = ezxml_child(node, "detect_blank")) != NULL) {
if(strcasecmp(cur_node->txt,"false")) {
cache->detect_blank = 1;
}
}
if ((cur_node = ezxml_child(node, "hitstats")) != NULL) {
if (!strcasecmp(cur_node->txt, "true")) {
ctx->set_error(ctx, 500, "sqlite config not supported anymore");
}
}
if ((cur_node = ezxml_child(node, "pragma")) != NULL) {
cache->pragmas = apr_table_make(ctx->pool,1);
while(cur_node) {
char *name = (char*)ezxml_attr(cur_node,"name");
if(!name || !cur_node->txt || !strlen(cur_node->txt)) {
ctx->set_error(ctx,500," missing name attribute");
return;
}
apr_table_set(cache->pragmas,name,cur_node->txt);
cur_node = cur_node->next;
}
}
if ((cur_node = ezxml_child(node, "queries")) != NULL) {
ezxml_t query_node;
if ((query_node = ezxml_child(cur_node, "exists")) != NULL) {
cache->exists_stmt.sql = apr_pstrdup(ctx->pool,query_node->txt);
}
if ((query_node = ezxml_child(cur_node, "get")) != NULL) {
cache->get_stmt.sql = apr_pstrdup(ctx->pool,query_node->txt);
}
if ((query_node = ezxml_child(cur_node, "set")) != NULL) {
cache->set_stmt.sql = apr_pstrdup(ctx->pool,query_node->txt);
}
if ((query_node = ezxml_child(cur_node, "delete")) != NULL) {
cache->delete_stmt.sql = apr_pstrdup(ctx->pool,query_node->txt);
}
if ((query_node = ezxml_child(cur_node, "create")) != NULL) {
cache->create_stmt.sql = apr_pstrdup(ctx->pool,query_node->txt);
}
}
cur_node = ezxml_child(node,"xcount");
if(cur_node && cur_node->txt && *cur_node->txt) {
char *endptr;
cache->count_x = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse xcount value %s for sqlite cache %s", cur_node->txt,cache->cache.name);
return;
}
}
cur_node = ezxml_child(node,"ycount");
if(cur_node && cur_node->txt && *cur_node->txt) {
char *endptr;
cache->count_y = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse ycount value %s for sqlite cache %s", cur_node->txt,cache->cache.name);
return;
}
}
cur_node = ezxml_child(node,"top");
if(cur_node && cur_node->txt && *cur_node->txt) {
char *endptr;
cache->top = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse top value %s for sqlite cache %s", cur_node->txt,cache->cache.name);
return;
}
}
}
/**
* \private \memberof mapcache_cache_sqlite
*/
static void _mapcache_cache_sqlite_configuration_post_config(mapcache_context *ctx,
mapcache_cache *pcache, mapcache_cfg *cfg)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*)pcache;
if (!cache->dbfile) {
ctx->set_error(ctx, 500, "sqlite cache \"%s\" is missing entry", pcache->name);
return;
}
}
/**
* \private \memberof mapcache_cache_sqlite
*/
static void _mapcache_cache_mbtiles_configuration_post_config(mapcache_context *ctx,
mapcache_cache *pcache, mapcache_cfg *cfg)
{
/* check that only one tileset/grid references this cache, as mbtiles does
not support multiple tilesets/grids per cache */
#ifdef FIXME
int nrefs = 0;
apr_hash_index_t *tileseti = apr_hash_first(ctx->pool,cfg->tilesets);
while(tileseti) {
mapcache_tileset *tileset;
const void *key;
apr_ssize_t keylen;
apr_hash_this(tileseti,&key,&keylen,(void**)&tileset);
if(tileset->cache == cache) {
nrefs++;
if(nrefs>1) {
ctx->set_error(ctx,500,"mbtiles cache %s is referenced by more than 1 tileset, which is not supported",cache->name);
return;
}
if(tileset->grid_links->nelts > 1) {
ctx->set_error(ctx,500,"mbtiles cache %s is referenced by tileset %s which has more than 1 grid, which is not supported",cache->name,tileset->name);
return;
}
}
tileseti = apr_hash_next(tileseti);
}
#endif
}
mapcache_cache* mapcache_cache_sqlite_create(mapcache_context *ctx)
{
mapcache_cache_sqlite *cache = apr_pcalloc(ctx->pool, sizeof (mapcache_cache_sqlite));
if (!cache) {
ctx->set_error(ctx, 500, "failed to allocate sqlite cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool, 3);
cache->cache.type = MAPCACHE_CACHE_SQLITE;
cache->cache._tile_delete = _mapcache_cache_sqlite_delete;
cache->cache._tile_get = _mapcache_cache_sqlite_get;
cache->cache._tile_exists = _mapcache_cache_sqlite_has_tile;
cache->cache._tile_set = _mapcache_cache_sqlite_set;
cache->cache._tile_multi_set = _mapcache_cache_sqlite_multi_set;
cache->cache.configuration_post_config = _mapcache_cache_sqlite_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_sqlite_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->create_stmt.sql = apr_pstrdup(ctx->pool,
"create table if not exists tiles(tileset text, grid text, x integer, y integer, z integer, data blob, dim text, ctime datetime, primary key(tileset,grid,x,y,z,dim))");
cache->exists_stmt.sql = apr_pstrdup(ctx->pool,
"select 1 from tiles where x=:x and y=:y and z=:z and dim=:dim and tileset=:tileset and grid=:grid");
cache->get_stmt.sql = apr_pstrdup(ctx->pool,
"select data,strftime(\"%s\",ctime) from tiles where tileset=:tileset and grid=:grid and x=:x and y=:y and z=:z and dim=:dim");
cache->set_stmt.sql = apr_pstrdup(ctx->pool,
"insert or replace into tiles(tileset,grid,x,y,z,data,dim,ctime) values (:tileset,:grid,:x,:y,:z,:data,:dim,datetime('now'))");
cache->delete_stmt.sql = apr_pstrdup(ctx->pool,
"delete from tiles where x=:x and y=:y and z=:z and dim=:dim and tileset=:tileset and grid=:grid");
cache->n_prepared_statements = 4;
cache->bind_stmt = _bind_sqlite_params;
cache->detect_blank = 1;
cache->x_fmt = cache->y_fmt = cache->z_fmt
= cache->inv_x_fmt = cache->inv_y_fmt
= cache->div_x_fmt = cache->div_y_fmt
= cache->inv_div_x_fmt = cache->inv_div_y_fmt
= cache->top_fmt = cache->top_x_fmt = cache->top_y_fmt
= cache->inv_top_x_fmt = cache->inv_top_y_fmt = apr_pstrdup(ctx->pool,"%d");
cache->count_x = cache->count_y = -1;
cache->top = -1;
return (mapcache_cache*)cache;
}
/**
* \brief creates and initializes a mapcache_sqlite_cache
*/
mapcache_cache* mapcache_cache_mbtiles_create(mapcache_context *ctx)
{
mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) mapcache_cache_sqlite_create(ctx);
if (!cache) {
return NULL;
}
cache->cache.configuration_post_config = _mapcache_cache_mbtiles_configuration_post_config;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->cache._tile_set = _mapcache_cache_mbtiles_set;
cache->cache._tile_multi_set = _mapcache_cache_mbtiles_multi_set;
cache->cache._tile_delete = _mapcache_cache_mbtiles_delete;
cache->create_stmt.sql = apr_pstrdup(ctx->pool,
"create table if not exists images(tile_id text, tile_data blob, primary key(tile_id));"\
"CREATE TABLE IF NOT EXISTS map (zoom_level integer, tile_column integer, tile_row integer, tile_id text, foreign key(tile_id) references images(tile_id), primary key(tile_row,tile_column,zoom_level));"\
"create table if not exists metadata(name text, value text);"\
"create view if not exists tiles AS SELECT map.zoom_level AS zoom_level, map.tile_column AS tile_column, map.tile_row AS tile_row, images.tile_data AS tile_data FROM map JOIN images ON images.tile_id = map.tile_id;"
);
cache->exists_stmt.sql = apr_pstrdup(ctx->pool,
"select 1 from tiles where tile_column=:x and tile_row=:y and zoom_level=:z");
cache->get_stmt.sql = apr_pstrdup(ctx->pool,
"select tile_data from tiles where tile_column=:x and tile_row=:y and zoom_level=:z");
cache->delete_stmt.sql = apr_pstrdup(ctx->pool,
"delete from tiles where tile_column=:x and tile_row=:y and zoom_level=:z");
cache->n_prepared_statements = 9;
cache->bind_stmt = _bind_mbtiles_params;
return (mapcache_cache*) cache;
}
#else
mapcache_cache* mapcache_cache_sqlite_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"SQLITE support not compiled in this version");
return NULL;
}
mapcache_cache* mapcache_cache_mbtiles_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"SQLITE (MBtiles) support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_tiff.c 0000664 0000000 0000000 00000134055 14653160677 0017131 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching: tiled tiff filesytem cache backend.
* Author: Thomas Bonfort
* Frank Warmerdam
* Even Rouault
* MapServer team.
*
******************************************************************************
* Copyright (c) 2011-2017 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_TIFF
#include
#include
#include
#include
#include
#include
#include
#ifdef USE_GDAL
#include "cpl_vsi.h"
#include "cpl_conv.h"
#define CPL_SERV_H_INCLUDED
#endif
#ifdef USE_GEOTIFF
#include "xtiffio.h"
#include "geovalues.h"
#include "geotiff.h"
#include "geo_normalize.h"
#include "geo_tiffp.h"
#include "geo_keyp.h"
#define MyTIFFOpen XTIFFOpen
#define MyTIFFClose XTIFFClose
#else
#define MyTIFFOpen TIFFOpen
#define MyTIFFClose TIFFClose
#endif
typedef enum
{
MAPCACHE_TIFF_STORAGE_FILE,
MAPCACHE_TIFF_STORAGE_REST,
MAPCACHE_TIFF_STORAGE_GOOGLE
} mapcache_cache_tiff_storage_type;
typedef struct mapcache_cache_tiff mapcache_cache_tiff;
struct mapcache_cache_tiff {
mapcache_cache cache;
char *filename_template;
char *x_fmt,*y_fmt,*z_fmt,*inv_x_fmt,*inv_y_fmt,*div_x_fmt,*div_y_fmt,*inv_div_x_fmt,*inv_div_y_fmt;
int count_x;
int count_y;
mapcache_image_format_jpeg *format;
mapcache_locker *locker;
struct {
mapcache_cache_tiff_storage_type type;
int connection_timeout;
int timeout;
char *header_file;
union
{
struct
{
char* access;
char* secret;
} google;
} u;
} storage;
};
#ifdef USE_GDAL
static tsize_t
_tiffReadProc( thandle_t th, tdata_t buf, tsize_t size )
{
VSILFILE* fp = (VSILFILE*)th;
return VSIFReadL( buf, 1, size, fp );
}
static tsize_t
_tiffWriteProc( thandle_t th, tdata_t buf, tsize_t size )
{
VSILFILE* fp = (VSILFILE*)th;
return VSIFWriteL( buf, 1, size, fp );
}
static toff_t
_tiffSeekProc( thandle_t th, toff_t off, int whence )
{
VSILFILE* fp = (VSILFILE*)th;
if( VSIFSeekL( fp, off, whence ) != 0 )
{
TIFFErrorExt( th, "_tiffSeekProc", "%s", VSIStrerror( errno ) );
return (toff_t)( -1 );
}
return VSIFTellL( fp );
}
static int
_tiffCloseProc( thandle_t th )
{
VSILFILE* fp = (VSILFILE*)th;
VSIFCloseL(fp);
return 0;
}
static toff_t
_tiffSizeProc( thandle_t th )
{
vsi_l_offset old_off;
toff_t file_size;
VSILFILE* fp = (VSILFILE*)th;
old_off = VSIFTellL( fp );
(void)VSIFSeekL( fp, 0, SEEK_END );
file_size = (toff_t) VSIFTellL( fp );
(void)VSIFSeekL( fp, old_off, SEEK_SET );
return file_size;
}
static int
_tiffMapProc( thandle_t th, tdata_t* pbase, toff_t* psize )
{
(void)th;
(void)pbase;
(void)psize;
/* Unimplemented */
return 0;
}
static void
_tiffUnmapProc( thandle_t th, tdata_t base, toff_t size )
{
(void)th;
(void)base;
(void)size;
/* Unimplemented */
}
static char* set_conf_value(const char* key, const char* value)
{
const char* old_val_const;
char* old_val = NULL;
old_val_const = CPLGetConfigOption(key, NULL);
if( old_val_const != NULL )
old_val = strdup(old_val_const);
/* Prevent a directory listing to be done */
CPLSetConfigOption(key, value);
return old_val;
}
static void restore_conf_value(const char* key, char* old_val)
{
CPLSetConfigOption(key, old_val);
free(old_val);
}
typedef struct
{
char* old_val_disable_readdir;
char* old_val_headerfile;
char* old_val_secret;
char* old_val_access;
} mapache_gdal_env_context;
static void set_gdal_context(mapcache_cache_tiff *cache,
mapache_gdal_env_context* pcontext)
{
memset(pcontext, 0, sizeof(mapache_gdal_env_context));
/* Prevent a directory listing to be done */
pcontext->old_val_disable_readdir =
set_conf_value("GDAL_DISABLE_READDIR_ON_OPEN", "YES");
if( cache->storage.header_file ) {
pcontext->old_val_headerfile = set_conf_value("GDAL_HTTP_HEADER_FILE",
cache->storage.header_file);
}
if( cache->storage.type == MAPCACHE_TIFF_STORAGE_GOOGLE ) {
pcontext->old_val_secret = set_conf_value("GS_SECRET_ACCESS_KEY",
cache->storage.u.google.secret);
pcontext->old_val_access = set_conf_value("GS_ACCESS_KEY_ID",
cache->storage.u.google.access);
}
}
static void restore_gdal_context(mapcache_cache_tiff *cache,
mapache_gdal_env_context* pcontext)
{
restore_conf_value("GDAL_DISABLE_READDIR_ON_OPEN",
pcontext->old_val_disable_readdir);
if( cache->storage.header_file ) {
restore_conf_value("GDAL_HTTP_HEADER_FILE",
pcontext->old_val_headerfile);
}
if( cache->storage.type == MAPCACHE_TIFF_STORAGE_GOOGLE ) {
restore_conf_value("GS_SECRET_ACCESS_KEY",
pcontext->old_val_secret);
restore_conf_value("GS_ACCESS_KEY_ID",
pcontext->old_val_access);
}
}
static int mapcache_cache_tiff_vsi_stat(
mapcache_cache_tiff *cache,
const char* name,
VSIStatBufL* pstat)
{
mapache_gdal_env_context context;
int ret;
set_gdal_context(cache, &context);
ret = VSIStatL(name, pstat);
restore_gdal_context(cache, &context);
return ret;
}
static VSILFILE* mapcache_cache_tiff_vsi_open(
mapcache_cache_tiff *cache,
const char* name, const char* mode )
{
mapache_gdal_env_context context;
VSILFILE* fp;
set_gdal_context(cache, &context);
fp = VSIFOpenL(name, mode);
restore_gdal_context(cache, &context);
return fp;
}
static TIFF* mapcache_cache_tiff_open(mapcache_context *ctx,
mapcache_cache_tiff *cache,
const char* name, const char* mode )
{
char chDummy;
VSILFILE* fp;
/* If writing or using a regular filename, then use standard */
/* libtiff/libgeotiff I/O layer */
if( strcmp(mode, "r") != 0 || strncmp(name, "/vsi", 4) != 0 )
{
return MyTIFFOpen(name, mode);
}
fp = mapcache_cache_tiff_vsi_open(cache, name, mode);
if( fp == NULL )
return NULL;
if( strcmp(mode, "r") == 0 )
{
/* But then the file descriptor may point to an invalid resource */
/* so try reading a byte from it */
if(VSIFReadL(&chDummy, 1, 1, fp) != 1)
{
VSIFCloseL(fp);
return NULL;
}
VSIFSeekL(fp, 0, SEEK_SET);
}
return
#ifdef USE_GEOTIFF
XTIFFClientOpen
#else
TIFFClientOpen
#endif
( name, mode,
(thandle_t) fp,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc );
}
static void CPL_STDCALL mapcache_cache_tiff_gdal_error_handler(CPLErr eErr,
int error_num,
const char* pszMsg)
{
#ifdef DEBUG
mapcache_context *ctx = (mapcache_context *) CPLGetErrorHandlerUserData();
ctx->log(ctx,MAPCACHE_DEBUG,"GDAL %s, %d: %s",
(eErr == CE_Failure) ? "Failure":
(eErr == CE_Warning) ? "Warning":
"Debug",
error_num,
pszMsg);
#endif
}
#else
static TIFF* mapcache_cache_tiff_open(mapcache_context *ctx,
mapcache_cache_tiff *cache,
const char* name, const char* mode )
{
(void)ctx;
(void)cache;
return MyTIFFOpen(name, mode);
}
#endif /* USE_GDAL */
#undef MyTIFFOpen
/**
* \brief return filename for given tile
*
* \param tile the tile to get the key from
* \param path pointer to a char* that will contain the filename
* \param r
* \private \memberof mapcache_cache_tiff
*/
static void _mapcache_cache_tiff_tile_key(mapcache_context *ctx, mapcache_cache_tiff *cache, mapcache_tile *tile, char **path)
{
if( cache->storage.type == MAPCACHE_TIFF_STORAGE_REST ) {
*path = apr_pstrcat(ctx->pool, "/vsicurl/", cache->filename_template, NULL);
}
else if( cache->storage.type == MAPCACHE_TIFF_STORAGE_GOOGLE &&
strncmp(cache->filename_template,
"https://storage.googleapis.com/",
strlen("https://storage.googleapis.com/")) == 0) {
*path = apr_pstrcat(ctx->pool, "/vsigs/",
cache->filename_template +
strlen("https://storage.googleapis.com/"), NULL);
}
else {
*path = apr_pstrdup(ctx->pool, cache->filename_template);
}
/*
* generic template substitutions
*/
if(strstr(*path,"{tileset}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{tileset}",
tile->tileset->name);
if(strstr(*path,"{grid}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{grid}",
tile->grid_link->grid->name);
if(tile->dimensions && strstr(*path,"{dim")) {
char *dimstring="";
int i = tile->dimensions->nelts;
while(i--) {
mapcache_requested_dimension *rdim = APR_ARRAY_IDX(tile->dimensions,i,mapcache_requested_dimension*);
const char *dimval = mapcache_util_str_sanitize(ctx->pool,rdim->cached_value,"/.",'#');
char *dim_key = apr_pstrcat(ctx->pool,"{dim:",rdim->dimension->name,"}",NULL);
dimstring = apr_pstrcat(ctx->pool,dimstring,"#",dimval,NULL);
if(strstr(*path,dim_key)) {
*path = mapcache_util_str_replace(ctx->pool,*path, dim_key, dimval);
}
}
*path = mapcache_util_str_replace(ctx->pool,*path, "{dim}", dimstring);
}
while(strstr(*path,"{z}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{z}",
apr_psprintf(ctx->pool,cache->z_fmt,tile->z));
/*
* x and y replacing, when the tiff files are numbered with an increasing
* x,y scheme (adjacent tiffs have x-x'=1 or y-y'=1
*/
while(strstr(*path,"{div_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{div_x}",
apr_psprintf(ctx->pool,cache->div_x_fmt,tile->x/cache->count_x));
while(strstr(*path,"{div_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{div_y}",
apr_psprintf(ctx->pool,cache->div_y_fmt,tile->y/cache->count_y));
while(strstr(*path,"{inv_div_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_div_y}",
apr_psprintf(ctx->pool,cache->inv_div_y_fmt,(tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1)/cache->count_y));
while(strstr(*path,"{inv_div_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_div_x}",
apr_psprintf(ctx->pool,cache->inv_div_x_fmt,(tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1)/cache->count_x));
/*
* x and y replacing, when the tiff files are numbered with the index
* of their bottom-left tile
* adjacent tiffs have x-x'=count_x or y-y'=count_y
*/
while(strstr(*path,"{x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{x}",
apr_psprintf(ctx->pool,cache->x_fmt,tile->x/cache->count_x*cache->count_x));
while(strstr(*path,"{y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{y}",
apr_psprintf(ctx->pool,cache->y_fmt,tile->y/cache->count_y*cache->count_y));
while(strstr(*path,"{inv_y}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_y}",
apr_psprintf(ctx->pool,cache->inv_y_fmt,(tile->grid_link->grid->levels[tile->z]->maxy - tile->y - 1)/cache->count_y*cache->count_y));
while(strstr(*path,"{inv_x}"))
*path = mapcache_util_str_replace(ctx->pool,*path, "{inv_x}",
apr_psprintf(ctx->pool,cache->inv_x_fmt,(tile->grid_link->grid->levels[tile->z]->maxx - tile->x - 1)/cache->count_x*cache->count_y));
if(!*path) {
ctx->set_error(ctx,500, "failed to allocate tile key");
}
}
#ifdef DEBUG
static void check_tiff_format(mapcache_context *ctx, mapcache_cache_tiff *cache, mapcache_tile *tile, TIFF *hTIFF, const char *filename)
{
uint32 imwidth,imheight,tilewidth,tileheight;
int16 planarconfig,orientation;
uint16 compression;
uint16 photometric;
int rv;
mapcache_grid_level *level;
int ntilesx;
int ntilesy;
TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &imwidth );
TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &imheight );
TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &tilewidth );
TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &tileheight );
/* Test that the TIFF is tiled and not stripped */
if(!TIFFIsTiled(hTIFF)) {
ctx->set_error(ctx,500,"TIFF file \"%s\" is not tiled", filename);
return;
}
/* check we have jpeg compression */
rv = TIFFGetField( hTIFF, TIFFTAG_COMPRESSION, &compression );
if(rv == 1 && compression != COMPRESSION_JPEG) {
ctx->set_error(ctx,500,"TIFF file \"%s\" is not jpeg compressed",
filename);
return;
}
/* tiff must be pixel interleaved, not with a single image per band */
rv = TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &planarconfig );
if(rv == 1 && planarconfig != PLANARCONFIG_CONTIG) {
ctx->set_error(ctx,500,"TIFF file \"%s\" is not pixel interleaved",
filename);
return;
}
/* is this test needed once we now we have JPEG ? */
rv = TIFFGetField( hTIFF, TIFFTAG_PHOTOMETRIC, &photometric );
if(rv == 1 && (photometric != PHOTOMETRIC_RGB && photometric != PHOTOMETRIC_YCBCR)) {
ctx->set_error(ctx,500,"TIFF file \"%s\" is not RGB: %d",
filename);
return;
}
/* the default is top-left, but check just in case */
rv = TIFFGetField( hTIFF, TIFFTAG_ORIENTATION, &orientation );
if(rv == 1 && orientation != ORIENTATION_TOPLEFT) {
ctx->set_error(ctx,500,"TIFF file \"%s\" is not top-left oriented",
filename);
return;
}
/* check that the tiff internal tiling aligns with the mapcache_grid we are using:
* - the tiff tile size must match the grid tile size
* - the number of tiles in each direction in the tiff must match what has been
* configured for the cache
*/
level = tile->grid_link->grid->levels[tile->z];
ntilesx = MAPCACHE_MIN(cache->count_x, level->maxx);
ntilesy = MAPCACHE_MIN(cache->count_y, level->maxy);
if( tilewidth != tile->grid_link->grid->tile_sx ||
tileheight != tile->grid_link->grid->tile_sy ||
imwidth != tile->grid_link->grid->tile_sx * ntilesx ||
imheight != tile->grid_link->grid->tile_sy * ntilesy ) {
ctx->set_error(ctx,500,"TIFF file %s imagesize (%d,%d) and tilesize (%d,%d).\
Expected (%d,%d),(%d,%d)",filename,imwidth,imheight,tilewidth,tileheight,
tile->grid_link->grid->tile_sx * ntilesx,
tile->grid_link->grid->tile_sy * ntilesy,
tile->grid_link->grid->tile_sx,
tile->grid_link->grid->tile_sy);
return;
}
/* TODO: more tests ? */
/* ok, success */
}
#endif
static int _mapcache_cache_tiff_has_tile(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *filename;
TIFF *hTIFF;
mapcache_cache_tiff *cache = (mapcache_cache_tiff*)pcache;
_mapcache_cache_tiff_tile_key(ctx, cache, tile, &filename);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
#ifdef USE_GDAL
CPLPushErrorHandlerEx(mapcache_cache_tiff_gdal_error_handler, ctx);
#endif
hTIFF = mapcache_cache_tiff_open(ctx,cache,filename,"r");
if(hTIFF) {
do {
uint32 nSubType = 0;
int tiff_offx, tiff_offy; /* the x and y offset of the tile inside the tiff image */
int tiff_off; /* the index of the tile inside the list of tiles of the tiff image */
mapcache_grid_level *level;
int ntilesx;
int ntilesy;
toff_t *offsets=NULL, *sizes=NULL;
if( !TIFFGetField(hTIFF, TIFFTAG_SUBFILETYPE, &nSubType) )
nSubType = 0;
/* skip overviews and masks */
if( (nSubType & FILETYPE_REDUCEDIMAGE) ||
(nSubType & FILETYPE_MASK) )
continue;
#ifdef DEBUG
check_tiff_format(ctx,cache,tile,hTIFF,filename);
if(GC_HAS_ERROR(ctx)) {
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FALSE;
}
#endif
level = tile->grid_link->grid->levels[tile->z];
ntilesx = MAPCACHE_MIN(cache->count_x, level->maxx);
ntilesy = MAPCACHE_MIN(cache->count_y, level->maxy);
/* x offset of the tile along a row */
tiff_offx = tile->x % ntilesx;
/*
* y offset of the requested row. we inverse it as the rows are ordered
* from top to bottom, whereas the tile y is bottom to top
*/
tiff_offy = ntilesy - (tile->y % ntilesy) -1;
tiff_off = tiff_offy * ntilesx + tiff_offx;
if(1 != TIFFGetField( hTIFF, TIFFTAG_TILEOFFSETS, &offsets )) {
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FALSE;
}
if(1 != TIFFGetField( hTIFF, TIFFTAG_TILEBYTECOUNTS, &sizes )) {
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FALSE;
}
MyTIFFClose(hTIFF);
if( offsets[tiff_off] > 0 && sizes[tiff_off] > 0 ) {
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_TRUE;
} else {
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FALSE;
}
} while( TIFFReadDirectory( hTIFF ) );
/* TIFF only contains overviews ? */
}
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FALSE;
}
static void _mapcache_cache_tiff_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
ctx->set_error(ctx,500,"TIFF cache tile deleting not implemented");
}
/**
* \brief get file content of given tile
*
* fills the mapcache_tile::data of the given tile with content stored in the file
* \private \memberof mapcache_cache_tiff
* \sa mapcache_cache::tile_get()
*/
static int _mapcache_cache_tiff_get(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
char *filename;
TIFF *hTIFF = NULL;
int rv;
mapcache_cache_tiff *cache = (mapcache_cache_tiff*)pcache;
_mapcache_cache_tiff_tile_key(ctx, cache, tile, &filename);
if(GC_HAS_ERROR(ctx)) {
return MAPCACHE_FALSE;
}
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"tile (%d,%d,%d) => filename %s)",
tile->x,tile->y,tile->z,filename);
#endif
#ifdef USE_GDAL
CPLPushErrorHandlerEx(mapcache_cache_tiff_gdal_error_handler, ctx);
#endif
hTIFF = mapcache_cache_tiff_open(ctx,cache,filename,"r");
/*
* we currrently have no way of knowing if the opening failed because the tif
* file does not exist (which is not an error condition, as it only signals
* that the requested tile does not exist in the cache), or if an other error
* that should be signaled occurred (access denied, not a tiff file, etc...)
*
* we ignore this case here and hope that further parts of the code will be
* able to detect what's happening more precisely
*/
if(hTIFF) {
do {
uint32 nSubType = 0;
int tiff_offx, tiff_offy; /* the x and y offset of the tile inside the tiff image */
int tiff_off; /* the index of the tile inside the list of tiles of the tiff image */
mapcache_grid_level *level;
int ntilesx;
int ntilesy;
toff_t *offsets=NULL, *sizes=NULL;
if( !TIFFGetField(hTIFF, TIFFTAG_SUBFILETYPE, &nSubType) )
nSubType = 0;
/* skip overviews */
if( nSubType & FILETYPE_REDUCEDIMAGE )
continue;
#ifdef DEBUG
check_tiff_format(ctx,cache,tile,hTIFF,filename);
if(GC_HAS_ERROR(ctx)) {
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
#endif
/*
* compute the width and height of the full tiff file. This
* is not simply the tile size times the number of tiles per
* file for lower zoom levels
*/
level = tile->grid_link->grid->levels[tile->z];
ntilesx = MAPCACHE_MIN(cache->count_x, level->maxx);
ntilesy = MAPCACHE_MIN(cache->count_y, level->maxy);
/* x offset of the tile along a row */
tiff_offx = tile->x % ntilesx;
/*
* y offset of the requested row. we inverse it as the rows are ordered
* from top to bottom, whereas the tile y is bottom to top
*/
tiff_offy = ntilesy - (tile->y % ntilesy) -1;
tiff_off = tiff_offy * ntilesx + tiff_offx;
/* get the offset of the jpeg data from the start of the file for each tile */
rv = TIFFGetField( hTIFF, TIFFTAG_TILEOFFSETS, &offsets );
if( rv != 1 ) {
ctx->set_error(ctx,500,"Failed to read TIFF file \"%s\" tile offsets",
filename);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
/* get the size of the jpeg data for each tile */
rv = TIFFGetField( hTIFF, TIFFTAG_TILEBYTECOUNTS, &sizes );
if( rv != 1 ) {
ctx->set_error(ctx,500,"Failed to read TIFF file \"%s\" tile sizes",
filename);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
/*
* the tile data exists for the given tiff_off if both offsets and size
* are not zero for that index.
* if not, the tiff file is sparse and is missing the requested tile
*/
if( offsets[tiff_off] > 0 && sizes[tiff_off] >= 2 ) {
apr_file_t *f;
apr_finfo_t finfo;
apr_status_t ret;
/* read the jpeg header (common to all tiles) */
uint32 jpegtable_size = 0;
unsigned char* jpegtable_ptr;
rv = TIFFGetField( hTIFF, TIFFTAG_JPEGTABLES, &jpegtable_size, &jpegtable_ptr );
if( rv != 1 || !jpegtable_ptr || jpegtable_size < 2) {
/* there is no common jpeg header in the tiff tags */
ctx->set_error(ctx,500,"Failed to read TIFF file \"%s\" jpeg table",
filename);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
/*
* open the tiff file directly to access the jpeg image data with the given
* offset
*/
#ifdef USE_GDAL
if( cache->storage.type != MAPCACHE_TIFF_STORAGE_FILE )
{
char *bufptr;
apr_off_t off;
apr_size_t bytes_to_read;
size_t bytes_read;
VSIStatBufL sStat;
VSILFILE* fp;
fp = mapcache_cache_tiff_vsi_open(cache, filename, "r");
if( fp == NULL )
{
/*
* shouldn't usually happen. we managed to open the file before,
* nothing much to do except bail out.
*/
ctx->set_error(ctx,500,
"VSIFOpenL() failed on already open tiff "
"file \"%s\", giving up .... ",
filename);
MyTIFFClose(hTIFF);
CPLPopErrorHandler();
return MAPCACHE_FAILURE;
}
if( mapcache_cache_tiff_vsi_stat(cache, filename, &sStat) == 0 ) {
/*
* extract the file modification time. this isn't guaranteed to be the
* modification time of the actual tile, but it's the best we can do
*/
tile->mtime = sStat.st_mtime;
}
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"tile (%d,%d,%d) => mtime = %d)",
tile->x,tile->y,tile->z,tile->mtime);
#endif
/* create a memory buffer to contain the jpeg data */
tile->encoded_data = mapcache_buffer_create(
(jpegtable_size+sizes[tiff_off]-4),ctx->pool);
/*
* copy the jpeg header to the beginning of the memory buffer,
* omitting the last 2 bytes
*/
memcpy(tile->encoded_data->buf,jpegtable_ptr,(jpegtable_size-2));
/* advance the data pointer to after the header data */
bufptr = ((char *)tile->encoded_data->buf) + (jpegtable_size-2);
/* go to the specified offset in the tiff file, plus 2 bytes */
off = offsets[tiff_off]+2;
VSIFSeekL(fp, (vsi_l_offset)off, SEEK_SET);
/*
* copy the jpeg body at the end of the memory buffer, accounting
* for the two bytes we omitted in the previous step
*/
bytes_to_read = sizes[tiff_off]-2;
bytes_read = VSIFReadL(bufptr, 1, bytes_to_read, fp);
/* check we have correctly read the requested number of bytes */
if(bytes_to_read != bytes_read) {
ctx->set_error(ctx,500,"failed to read jpeg body in \"%s\".\
(read %d of %d bytes)",
filename,(int)bytes_read,(int)sizes[tiff_off]-2);
VSIFCloseL(fp);
MyTIFFClose(hTIFF);
CPLPopErrorHandler();
return MAPCACHE_FAILURE;
}
tile->encoded_data->size = (jpegtable_size+sizes[tiff_off]-4);
VSIFCloseL(fp);
CPLPopErrorHandler();
return MAPCACHE_SUCCESS;
}
else
#endif
if((ret=apr_file_open(&f, filename,
APR_FOPEN_READ|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,APR_OS_DEFAULT,
ctx->pool)) == APR_SUCCESS) {
char *bufptr;
apr_off_t off;
apr_size_t bytes;
ret = apr_file_info_get(&finfo, APR_FINFO_MTIME, f);
if(ret == APR_SUCCESS) {
/*
* extract the file modification time. this isn't guaranteed to be the
* modification time of the actual tile, but it's the best we can do
*/
tile->mtime = finfo.mtime;
}
/* create a memory buffer to contain the jpeg data */
tile->encoded_data = mapcache_buffer_create((jpegtable_size+sizes[tiff_off]-4),ctx->pool);
/*
* copy the jpeg header to the beginning of the memory buffer,
* omitting the last 2 bytes
*/
memcpy(tile->encoded_data->buf,jpegtable_ptr,(jpegtable_size-2));
/* advance the data pointer to after the header data */
bufptr = ((char *)tile->encoded_data->buf) + (jpegtable_size-2);
/* go to the specified offset in the tiff file, plus 2 bytes */
off = offsets[tiff_off]+2;
apr_file_seek(f,APR_SET,&off);
/*
* copy the jpeg body at the end of the memory buffer, accounting
* for the two bytes we omitted in the previous step
*/
bytes = sizes[tiff_off]-2;
apr_file_read(f,bufptr,&bytes);
/* check we have correctly read the requested number of bytes */
if(bytes != sizes[tiff_off]-2) {
ctx->set_error(ctx,500,"failed to read jpeg body in \"%s\".\
(read %d of %d bytes)", filename,bytes,sizes[tiff_off]-2);
apr_file_close(f);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
tile->encoded_data->size = (jpegtable_size+sizes[tiff_off]-4);
/* finalize and cleanup */
apr_file_close(f);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_SUCCESS;
} else {
/* shouldn't usually happen. we managed to open the file with TIFFOpen,
* but apr_file_open failed to do so.
* nothing much to do except bail out.
*/
ctx->set_error(ctx,500,"apr_file_open failed on already open tiff file \"%s\", giving up .... ",
filename);
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_FAILURE;
}
} else {
/* sparse tiff file without the requested tile */
MyTIFFClose(hTIFF);
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
return MAPCACHE_CACHE_MISS;
}
} /* loop through the tiff directories if there are multiple ones */
while( TIFFReadDirectory( hTIFF ) );
/*
* should not happen?
* finished looping through directories and didn't find anything suitable.
* does the file only contain overviews?
*/
MyTIFFClose(hTIFF);
}
#ifdef USE_GDAL
CPLPopErrorHandler();
#endif
/* failed to open tiff file */
return MAPCACHE_CACHE_MISS;
}
/**
* \brief write tile data to tiff
*
* writes the content of mapcache_tile::data to tiff.
* \returns MAPCACHE_FAILURE if there is no data to write, or if the tile isn't locked
* \returns MAPCACHE_SUCCESS if the tile has been successfully written to tiff
* \private \memberof mapcache_cache_tiff
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_tiff_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
#ifdef USE_TIFF_WRITE
char *filename;
TIFF *hTIFF = NULL;
int rv;
void *lock;
int create;
mapcache_cache_tiff *cache;
mapcache_image_format_jpeg *format;
int tilew;
int tileh;
unsigned char *rgb;
int r,c;
apr_finfo_t finfo;
mapcache_grid_level *level;
int ntilesx;
int ntilesy;
int tiff_offx, tiff_offy; /* the x and y offset of the tile inside the tiff image */
int tiff_off; /* the index of the tile inside the list of tiles of the tiff image */
cache = (mapcache_cache_tiff*)pcache;
if( cache->storage.type != MAPCACHE_TIFF_STORAGE_FILE )
{
ctx->set_error(ctx,500,"tiff cache %s is read-only\n",pcache->name);
return;
}
_mapcache_cache_tiff_tile_key(ctx, cache, tile, &filename);
format = (mapcache_image_format_jpeg*) cache->format;
if(GC_HAS_ERROR(ctx)) {
return;
}
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"tile write (%d,%d,%d) => filename %s)",
tile->x,tile->y,tile->z,filename);
#endif
/*
* create the directory where the tiff file will be stored
*/
mapcache_make_parent_dirs(ctx,filename);
GC_CHECK_ERROR(ctx);
tilew = tile->grid_link->grid->tile_sx;
tileh = tile->grid_link->grid->tile_sy;
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
/* remap xrgb to rgb */
rgb = (unsigned char*)malloc(tilew*tileh*3);
for(r=0; rraw_image->h; r++) {
unsigned char *imptr = tile->raw_image->data + r * tile->raw_image->stride;
unsigned char *rgbptr = rgb + r * tilew * 3;
for(c=0; craw_image->w; c++) {
rgbptr[0] = imptr[2];
rgbptr[1] = imptr[1];
rgbptr[2] = imptr[0];
rgbptr += 3;
imptr += 4;
}
}
/*
* aquire a lock on the tiff file.
*/
while(mapcache_lock_or_wait_for_resource(ctx,(cache->locker?cache->locker:ctx->config->locker),filename, &lock) == MAPCACHE_FALSE);
/* check if the tiff file exists already */
rv = apr_stat(&finfo,filename,0,ctx->pool);
if(!APR_STATUS_IS_ENOENT(rv)) {
hTIFF = mapcache_cache_tiff_open(ctx,cache,filename,"r+");
create = 0;
} else {
hTIFF = mapcache_cache_tiff_open(ctx,cache,filename,"w+");
create = 1;
}
if(!hTIFF) {
ctx->set_error(ctx,500,"failed to open/create tiff file %s\n",filename);
goto close_tiff;
}
/*
* compute the width and height of the full tiff file. This
* is not simply the tile size times the number of tiles per
* file for lower zoom levels
*/
level = tile->grid_link->grid->levels[tile->z];
ntilesx = MAPCACHE_MIN(cache->count_x, level->maxx);
ntilesy = MAPCACHE_MIN(cache->count_y, level->maxy);
if(create) {
#ifdef USE_GEOTIFF
double adfPixelScale[3], adfTiePoints[6];
mapcache_extent bbox;
GTIF *gtif;
int x,y;
#endif
/* populate the TIFF tags if we are creating the file */
TIFFSetField( hTIFF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT );
TIFFSetField( hTIFF, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
TIFFSetField( hTIFF, TIFFTAG_BITSPERSAMPLE, 8 );
TIFFSetField( hTIFF, TIFFTAG_COMPRESSION, COMPRESSION_JPEG );
TIFFSetField( hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB );
TIFFSetField( hTIFF, TIFFTAG_TILEWIDTH, tilew );
TIFFSetField( hTIFF, TIFFTAG_TILELENGTH, tileh );
TIFFSetField( hTIFF, TIFFTAG_IMAGEWIDTH, ntilesx * tilew );
TIFFSetField( hTIFF, TIFFTAG_IMAGELENGTH, ntilesy * tileh );
TIFFSetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL,3 );
#ifdef USE_GEOTIFF
gtif = GTIFNew(hTIFF);
if(gtif) {
GTIFKeySet(gtif, GTRasterTypeGeoKey, TYPE_SHORT, 1,
RasterPixelIsArea);
GTIFKeySet( gtif, GeographicTypeGeoKey, TYPE_SHORT, 1,
0 );
GTIFKeySet( gtif, GeogGeodeticDatumGeoKey, TYPE_SHORT,
1, 0 );
GTIFKeySet( gtif, GeogEllipsoidGeoKey, TYPE_SHORT, 1,
0 );
GTIFKeySet( gtif, GeogSemiMajorAxisGeoKey, TYPE_DOUBLE, 1,
0.0 );
GTIFKeySet( gtif, GeogSemiMinorAxisGeoKey, TYPE_DOUBLE, 1,
0.0 );
switch(tile->grid_link->grid->unit) {
case MAPCACHE_UNIT_FEET:
GTIFKeySet( gtif, ProjLinearUnitsGeoKey, TYPE_SHORT, 1,
Linear_Foot );
break;
case MAPCACHE_UNIT_METERS:
GTIFKeySet( gtif, ProjLinearUnitsGeoKey, TYPE_SHORT, 1,
Linear_Meter );
break;
case MAPCACHE_UNIT_DEGREES:
GTIFKeySet(gtif, GeogAngularUnitsGeoKey, TYPE_SHORT, 0,
Angular_Degree );
break;
default:
break;
}
GTIFWriteKeys(gtif);
GTIFFree(gtif);
adfPixelScale[0] = adfPixelScale[1] = level->resolution;
adfPixelScale[2] = 0.0;
TIFFSetField( hTIFF, TIFFTAG_GEOPIXELSCALE, 3, adfPixelScale );
/* top left tile x,y */
x = (tile->x / cache->count_x)*(cache->count_x);
y = (tile->y / cache->count_y)*(cache->count_y) + ntilesy - 1;
mapcache_grid_get_tile_extent(ctx, tile->grid_link->grid,
x,y,tile->z,&bbox);
adfTiePoints[0] = 0.0;
adfTiePoints[1] = 0.0;
adfTiePoints[2] = 0.0;
adfTiePoints[3] = bbox.minx;
adfTiePoints[4] = bbox.maxy;
adfTiePoints[5] = 0.0;
TIFFSetField( hTIFF, TIFFTAG_GEOTIEPOINTS, 6, adfTiePoints );
}
#endif
}
TIFFSetField(hTIFF, TIFFTAG_JPEGQUALITY, format->quality);
if(format->photometric == MAPCACHE_PHOTOMETRIC_RGB) {
TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
} else {
TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
}
TIFFSetField( hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB );
/* x offset of the tile along a row */
tiff_offx = tile->x % ntilesx;
/*
* y offset of the requested row. we inverse it as the rows are ordered
* from top to bottom, whereas the tile y is bottom to top
*/
tiff_offy = ntilesy - (tile->y % ntilesy) -1;
tiff_off = tiff_offy * ntilesx + tiff_offx;
rv = TIFFWriteEncodedTile(hTIFF, tiff_off, rgb, tilew*tileh*3);
free(rgb);
if(!rv) {
ctx->set_error(ctx,500,"failed TIFFWriteEncodedTile to %s",filename);
goto close_tiff;
}
rv = TIFFWriteCheck( hTIFF, 1, "cache_set()");
if(!rv) {
ctx->set_error(ctx,500,"failed TIFFWriteCheck %s",filename);
goto close_tiff;
}
if(create) {
rv = TIFFWriteDirectory(hTIFF);
if(!rv) {
ctx->set_error(ctx,500,"failed TIFFWriteDirectory to %s",filename);
goto close_tiff;
}
}
close_tiff:
if(hTIFF)
MyTIFFClose(hTIFF);
mapcache_unlock_resource(ctx,cache->locker?cache->locker:ctx->config->locker, lock);
#else
ctx->set_error(ctx,500,"tiff write support disabled by default");
#endif
}
/**
* \private \memberof mapcache_cache_tiff
*/
static void _mapcache_cache_tiff_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *pcache, mapcache_cfg *config)
{
ezxml_t cur_node;
mapcache_cache_tiff *cache = (mapcache_cache_tiff*)pcache;
char * format_name;
mapcache_image_format *pformat;
if ((cur_node = ezxml_child(node,"template")) != NULL) {
char *fmt;
cache->filename_template = apr_pstrdup(ctx->pool,cur_node->txt);
fmt = (char*)ezxml_attr(cur_node,"x_fmt");
if(fmt && *fmt) {
cache->x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"y_fmt");
if(fmt && *fmt) {
cache->y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"z_fmt");
if(fmt && *fmt) {
cache->z_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_x_fmt");
if(fmt && *fmt) {
cache->inv_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_y_fmt");
if(fmt && *fmt) {
cache->inv_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"div_x_fmt");
if(fmt && *fmt) {
cache->div_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"div_y_fmt");
if(fmt && *fmt) {
cache->div_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_div_x_fmt");
if(fmt && *fmt) {
cache->inv_div_x_fmt = apr_pstrdup(ctx->pool,fmt);
}
fmt = (char*)ezxml_attr(cur_node,"inv_div_y_fmt");
if(fmt && *fmt) {
cache->inv_div_y_fmt = apr_pstrdup(ctx->pool,fmt);
}
}
cur_node = ezxml_child(node,"xcount");
if(cur_node && cur_node->txt && *cur_node->txt) {
char *endptr;
cache->count_x = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse xcount value %s for tiff cache %s", cur_node->txt,pcache->name);
return;
}
}
cur_node = ezxml_child(node,"ycount");
if(cur_node && cur_node->txt && *cur_node->txt) {
char *endptr;
cache->count_y = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx,400,"failed to parse ycount value %s for tiff cache %s", cur_node->txt,pcache->name);
return;
}
}
cur_node = ezxml_child(node,"format");
if(cur_node && cur_node->txt && *cur_node->txt) {
format_name = cur_node->txt;
} else {
format_name = "JPEG";
}
pformat = mapcache_configuration_get_image_format(
config,format_name);
if(!pformat) {
ctx->set_error(ctx,500,"TIFF cache %s references unknown image format %s",
pcache->name, format_name);
return;
}
if(pformat->type != GC_JPEG) {
ctx->set_error(ctx,500,"TIFF cache %s can only reference a JPEG image format",
pcache->name);
return;
}
cache->format = (mapcache_image_format_jpeg*)pformat;
cur_node = ezxml_child(node,"locker");
if(cur_node) {
mapcache_config_parse_locker(ctx, cur_node, &cache->locker);
}
cache->storage.type = MAPCACHE_TIFF_STORAGE_FILE;
cur_node = ezxml_child(node,"storage");
if (cur_node) {
ezxml_t child_node;
const char *type = ezxml_attr(cur_node,"type");
if( !type ) {
ctx->set_error(ctx,400,
" with no \"type\" attribute in cache (%s)",
pcache->name);
return;
}
if( strcmp(type, "rest") == 0 ) {
cache->storage.type = MAPCACHE_TIFF_STORAGE_REST;
}
else if( strcmp(type, "google") == 0 ) {
cache->storage.type = MAPCACHE_TIFF_STORAGE_GOOGLE;
if ((child_node = ezxml_child(cur_node,"access")) != NULL) {
cache->storage.u.google.access =
apr_pstrdup(ctx->pool, child_node->txt);
} else if ( getenv("GS_ACCESS_KEY_ID")) {
cache->storage.u.google.access =
apr_pstrdup(ctx->pool,getenv("GS_ACCESS_KEY_ID"));
} else {
ctx->set_error(ctx,400,
"google storage in cache (%s) is missing "
"required child", pcache->name);
return;
}
if ((child_node = ezxml_child(cur_node,"secret")) != NULL) {
cache->storage.u.google.secret =
apr_pstrdup(ctx->pool, child_node->txt);
} else if ( getenv("GS_SECRET_ACCESS_KEY")) {
cache->storage.u.google.access =
apr_pstrdup(ctx->pool,getenv("GS_SECRET_ACCESS_KEY"));
} else {
ctx->set_error(ctx,400,
"google storage in cache (%s) is missing "
"required child", pcache->name);
return;
}
}
else {
ctx->set_error(ctx, 400, "unknown cache type %s for cache \"%s\"",
type, pcache->name);
return;
}
if ((child_node = ezxml_child(cur_node,"connection_timeout")) != NULL) {
char *endptr;
cache->storage.connection_timeout = (int)strtol(child_node->txt,&endptr,10);
if(*endptr != 0 || cache->storage.connection_timeout<1) {
ctx->set_error(ctx,400,"invalid rest cache "
"\"%s\" (positive integer expected)",
child_node->txt);
return;
}
} else {
cache->storage.connection_timeout = 30;
}
if ((child_node = ezxml_child(cur_node,"timeout")) != NULL) {
char *endptr;
cache->storage.timeout = (int)strtol(child_node->txt,&endptr,10);
if(*endptr != 0 || cache->storage.timeout<1) {
ctx->set_error(ctx,400,"invalid rest cache \"%s\" "
"(positive integer expected)",
child_node->txt);
return;
}
} else {
cache->storage.timeout = 120;
}
if ((child_node = ezxml_child(cur_node,"header_file")) != NULL) {
cache->storage.header_file = apr_pstrdup(ctx->pool, child_node->txt);
}
}
}
/**
* \private \memberof mapcache_cache_tiff
*/
static void _mapcache_cache_tiff_configuration_post_config(mapcache_context *ctx, mapcache_cache *pcache,
mapcache_cfg *cfg)
{
mapcache_cache_tiff *cache = (mapcache_cache_tiff*)pcache;
/* check all required parameters are configured */
if((!cache->filename_template || !strlen(cache->filename_template))) {
ctx->set_error(ctx, 400, "tiff cache %s has no template pattern",cache->cache.name);
return;
}
if(cache->count_x <= 0 || cache->count_y <= 0) {
ctx->set_error(ctx, 400, "tiff cache %s has invalid count (%d,%d)",cache->count_x,cache->count_y);
return;
}
#ifdef USE_GDAL
if(cache->storage.type == MAPCACHE_TIFF_STORAGE_REST &&
strncmp(cache->filename_template, "http://", 6) != 0 &&
strncmp(cache->filename_template, "https://", 7) != 0 ) {
ctx->set_error(ctx, 400, "tiff cache %s template pattern should begin with http:// or https://",cache->cache.name);
return;
}
if(cache->storage.type == MAPCACHE_TIFF_STORAGE_GOOGLE &&
strncmp(cache->filename_template, "https://storage.googleapis.com/",
strlen("https://storage.googleapis.com/")) != 0 &&
strncmp(cache->filename_template, "/vsigs/",
strlen("/vsigs/")) != 0 ) {
ctx->set_error(ctx, 400, "tiff cache %s template pattern should begin "
"with https://storage.googleapis.com/ or /vsigs/",cache->cache.name);
return;
}
#else
if(cache->storage.type != MAPCACHE_TIFF_STORAGE_FILE )
{
ctx->set_error(ctx, 400, "tiff cache %s cannot use a network based "
"storage due to mising GDAL dependency",
cache->cache.name);
return;
}
#endif
}
/**
* \brief creates and initializes a mapcache_tiff_cache
*/
mapcache_cache* mapcache_cache_tiff_create(mapcache_context *ctx)
{
mapcache_cache_tiff *cache = apr_pcalloc(ctx->pool,sizeof(mapcache_cache_tiff));
if(!cache) {
ctx->set_error(ctx, 500, "failed to allocate tiff cache");
return NULL;
}
cache->cache.metadata = apr_table_make(ctx->pool,3);
cache->cache.type = MAPCACHE_CACHE_TIFF;
cache->cache._tile_delete = _mapcache_cache_tiff_delete;
cache->cache._tile_get = _mapcache_cache_tiff_get;
cache->cache._tile_exists = _mapcache_cache_tiff_has_tile;
cache->cache._tile_set = _mapcache_cache_tiff_set;
cache->cache.configuration_post_config = _mapcache_cache_tiff_configuration_post_config;
cache->cache.configuration_parse_xml = _mapcache_cache_tiff_configuration_parse_xml;
cache->cache.child_init = mapcache_cache_child_init_noop;
cache->count_x = 10;
cache->count_y = 10;
cache->x_fmt = cache->y_fmt = cache->z_fmt
= cache->inv_x_fmt = cache->inv_y_fmt
= cache->div_x_fmt = cache->div_y_fmt
= cache->inv_div_x_fmt = cache->inv_div_y_fmt = apr_pstrdup(ctx->pool,"%d");
#ifndef DEBUG
TIFFSetWarningHandler(NULL);
TIFFSetErrorHandler(NULL);
#endif
return (mapcache_cache*)cache;
}
#else
mapcache_cache* mapcache_cache_tiff_create(mapcache_context *ctx) {
ctx->set_error(ctx,400,"TIFF support not compiled in this version");
return NULL;
}
#endif
/* vim: ts=2 sts=2 et sw=2
*/
mapcache-rel-1-14-1/lib/cache_tokyocabinet.c 0000664 0000000 0000000 00000020544 14653160677 0020671 0 ustar 00root root 0000000 0000000 /******************************************************************************
* $Id$
*
* Project: MapServer
* Purpose: MapCache tile caching support file: Tokyo Cabinet cache backend
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2011 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapcache.h"
#ifdef USE_TC
#include
#include
#include
#include
#include
#include
#include
#include