Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  WMS Client Driver
       4             :  * Purpose:  Supporting utility functions for GDAL WMS driver.
       5             :  * Author:   Adam Nowacki, nowak@xpam.de
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2007, Adam Nowacki
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "wmsdriver.h"
      14             : 
      15         169 : OGRSpatialReference ProjToSRS(const CPLString &proj)
      16             : {
      17         169 :     OGRSpatialReference sr;
      18         169 :     sr.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
      19         338 :     CPLString srs;
      20             : 
      21             :     /* We could of course recognize OSGEO:41001 to SetFromUserInput(), but this
      22             :      * hackish SRS */
      23             :     /* is almost only used in the context of WMS */
      24         169 :     if (strcmp(proj.c_str(), "OSGEO:41001") == 0)
      25             :     {
      26           0 :         sr.importFromEPSG(3857);
      27             :     }
      28         169 :     else if (EQUAL(proj.c_str(), "EPSG:NONE"))
      29             :     {
      30             :         // do nothing
      31             :     }
      32             :     else
      33             :     {
      34         169 :         sr.SetFromUserInput(
      35             :             proj.c_str(),
      36             :             OGRSpatialReference::SET_FROM_USER_INPUT_LIMITATIONS_get());
      37             :     }
      38         338 :     return sr;
      39             : }
      40             : 
      41             : // Terminates an URL base with either ? or &, so extra args can be appended
      42           7 : void URLPrepare(CPLString &url)
      43             : {
      44           7 :     if (url.find("?") == std::string::npos)
      45             :     {
      46           1 :         url.append("?");
      47             :     }
      48             :     else
      49             :     {
      50           6 :         if (*url.rbegin() != '?' && *url.rbegin() != '&')
      51           2 :             url.append("&");
      52             :     }
      53           7 : }
      54             : 
      55          38 : CPLString BufferToVSIFile(GByte *buffer, size_t size)
      56             : {
      57          76 :     const CPLString file_name(VSIMemGenerateHiddenFilename("wmsresult.dat"));
      58          38 :     VSILFILE *f = VSIFileFromMemBuffer(file_name.c_str(), buffer, size, false);
      59          38 :     if (f == nullptr)
      60           0 :         return CPLString();
      61          38 :     VSIFCloseL(f);
      62          38 :     return file_name;
      63             : }
      64             : 
      65          30 : int VersionStringToInt(const char *version)
      66             : {
      67          30 :     if (version == nullptr)
      68           0 :         return -1;
      69          30 :     const char *p = version;
      70          30 :     int v = 0;
      71         150 :     for (int i = 3; i >= 0; --i)
      72             :     {
      73         120 :         int n = atoi(p);
      74         120 :         if (n < 0 || n >= 100)
      75           0 :             return -1;
      76         120 :         v += (1 << (i * 8)) * n;
      77         206 :         for (; (*p != '\0') && (*p != '.'); ++p)
      78             :             ;
      79         120 :         if (*p != '\0')
      80          56 :             ++p;
      81             :     }
      82          30 :     return v;
      83             : }
      84             : 
      85         781 : int StrToBool(const char *p)
      86             : {
      87         781 :     if (p == nullptr)
      88           0 :         return -1;
      89         781 :     if (EQUAL(p, "1") || EQUAL(p, "true") || EQUAL(p, "yes") ||
      90         261 :         EQUAL(p, "enable") || EQUAL(p, "enabled") || EQUAL(p, "on"))
      91         520 :         return 1;
      92         261 :     if (EQUAL(p, "0") || EQUAL(p, "false") || EQUAL(p, "no") ||
      93           0 :         EQUAL(p, "disable") || EQUAL(p, "disabled") || EQUAL(p, "off"))
      94         261 :         return 0;
      95           0 :     return -1;
      96             : }
      97             : 
      98        1269 : int URLSearchAndReplace(CPLString *base, const char *search, const char *fmt,
      99             :                         ...)
     100             : {
     101        2538 :     CPLString tmp;
     102             :     va_list args;
     103             : 
     104        1269 :     size_t start = base->find(search);
     105        1269 :     if (start == std::string::npos)
     106             :     {
     107        1113 :         return -1;
     108             :     }
     109             : 
     110         156 :     va_start(args, fmt);
     111         156 :     tmp.vPrintf(fmt, args);
     112         156 :     va_end(args);
     113             : 
     114         156 :     base->replace(start, strlen(search), tmp);
     115         156 :     return static_cast<int>(start);
     116             : }
     117             : 
     118             : // decode s from base64, XMLencoded or read from the file name s
     119           1 : const char *WMSUtilDecode(CPLString &s, const char *encoding)
     120             : {
     121           1 :     if (EQUAL(encoding, "base64"))
     122             :     {
     123           2 :         std::vector<char> buffer(s.begin(), s.end());
     124           1 :         buffer.push_back('\0');
     125             :         int nSize =
     126           1 :             CPLBase64DecodeInPlace(reinterpret_cast<GByte *>(&buffer[0]));
     127           1 :         s.assign(&buffer[0], nSize);
     128             :     }
     129           0 :     else if (EQUAL(encoding, "XMLencoded"))
     130             :     {
     131           0 :         int len = static_cast<int>(s.size());
     132           0 :         char *result = CPLUnescapeString(s.c_str(), &len, CPLES_XML);
     133           0 :         s.assign(result, static_cast<size_t>(len));
     134           0 :         CPLFree(result);
     135             :     }
     136           0 :     else if (EQUAL(encoding, "file"))
     137             :     {  // Not an encoding but an external file
     138           0 :         VSILFILE *f = VSIFOpenL(s.c_str(), "rb");
     139           0 :         s.clear();  // Return an empty string if file can't be opened or read
     140           0 :         if (f)
     141             :         {
     142           0 :             VSIFSeekL(f, 0, SEEK_END);
     143           0 :             size_t size = static_cast<size_t>(VSIFTellL(f));
     144           0 :             VSIFSeekL(f, 0, SEEK_SET);
     145           0 :             std::vector<char> buffer(size);
     146           0 :             if (VSIFReadL(reinterpret_cast<void *>(&buffer[0]), size, 1, f))
     147           0 :                 s.assign(&buffer[0], buffer.size());
     148           0 :             VSIFCloseL(f);
     149             :         }
     150             :     }
     151           1 :     return s.c_str();
     152             : }