Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  GDAL
       4             :  * Purpose:  GDALJP2Metadata: metadata generator
       5             :  * Author:   Even Rouault <even dot rouault at spatialys dot com>
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2015, European Union Satellite Centre
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "cpl_port.h"
      14             : #include "gdaljp2metadatagenerator.h"
      15             : 
      16             : #include <cstddef>
      17             : 
      18             : #ifdef HAVE_LIBXML2
      19             : 
      20             : #if defined(__GNUC__)
      21             : #pragma GCC diagnostic push
      22             : #pragma GCC diagnostic ignored "-Wold-style-cast"
      23             : #endif
      24             : 
      25             : #ifdef __clang__
      26             : #pragma clang diagnostic push
      27             : #pragma clang diagnostic ignored "-Wunknown-pragmas"
      28             : #pragma clang diagnostic ignored "-Wdocumentation"
      29             : #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
      30             : #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
      31             : #endif
      32             : 
      33             : #include <libxml/parser.h>
      34             : #include <libxml/tree.h>
      35             : #include <libxml/xpath.h>
      36             : #include <libxml/xpathInternals.h>
      37             : 
      38             : #ifdef __clang__
      39             : #pragma clang diagnostic pop
      40             : #endif
      41             : 
      42             : #if defined(__GNUC__)
      43             : #pragma GCC diagnostic pop
      44             : #endif
      45             : 
      46             : // For CHECK_ARITY and clang 5
      47             : // CHECK_ARITY: check the number of args passed to an XPath function matches.
      48             : #undef NULL
      49             : #define NULL nullptr
      50             : 
      51             : // Simplified version of the macro proposed by libxml2
      52             : // The reason is when running against filegdbAPI which includes it own copy
      53             : // of libxml2, and the check 'ctxt->valueNr < ctxt->valueFrame + (x)'
      54             : // done by libxml2 CHECK_ARITY() thus points to garbage
      55             : #undef CHECK_ARITY
      56             : #define CHECK_ARITY(x)                                                         \
      57             :     if (ctxt == NULL)                                                          \
      58             :         return;                                                                \
      59             :     if (nargs != (x))                                                          \
      60             :         XP_ERROR(XPATH_INVALID_ARITY);
      61             : 
      62             : /************************************************************************/
      63             : /*                            GDALGMLJP2Expr                            */
      64             : /************************************************************************/
      65             : 
      66             : enum class GDALGMLJP2ExprType
      67             : {
      68             :     GDALGMLJP2Expr_Unknown,
      69             :     GDALGMLJP2Expr_XPATH,
      70             :     GDALGMLJP2Expr_STRING_LITERAL,
      71             : };
      72             : 
      73             : class GDALGMLJP2Expr
      74             : {
      75             :     static void SkipSpaces(const char *&pszStr);
      76             : 
      77             :   public:
      78             :     GDALGMLJP2ExprType eType = GDALGMLJP2ExprType::GDALGMLJP2Expr_Unknown;
      79             :     CPLString osValue{};
      80             : 
      81           8 :     GDALGMLJP2Expr() = default;
      82             : 
      83           2 :     explicit GDALGMLJP2Expr(const char *pszVal)
      84           2 :         : eType(GDALGMLJP2ExprType::GDALGMLJP2Expr_STRING_LITERAL),
      85           2 :           osValue(pszVal)
      86             :     {
      87           2 :     }
      88             : 
      89           5 :     explicit GDALGMLJP2Expr(const CPLString &osVal)
      90           5 :         : eType(GDALGMLJP2ExprType::GDALGMLJP2Expr_STRING_LITERAL),
      91           5 :           osValue(osVal)
      92             :     {
      93           5 :     }
      94             : 
      95          15 :     ~GDALGMLJP2Expr() = default;
      96             : 
      97             :     GDALGMLJP2Expr Evaluate(xmlXPathContextPtr pXPathCtx, xmlDocPtr pDoc);
      98             : 
      99             :     static GDALGMLJP2Expr *Build(const char *pszOriStr, const char *&pszStr);
     100             :     static void
     101             :     ReportError(const char *pszOriStr, const char *pszStr,
     102             :                 const char *pszIntroMessage = "Parsing error at:\n");
     103             : };
     104             : 
     105             : /************************************************************************/
     106             : /*                         ReportError()                                */
     107             : /************************************************************************/
     108             : 
     109           5 : void GDALGMLJP2Expr::ReportError(const char *pszOriStr, const char *pszStr,
     110             :                                  const char *pszIntroMessage)
     111             : {
     112           5 :     size_t nDist = static_cast<size_t>(pszStr - pszOriStr);
     113           5 :     if (nDist > 40)
     114           0 :         nDist = 40;
     115          10 :     CPLString osErrMsg(pszIntroMessage);
     116          15 :     CPLString osInvalidExpr = CPLString(pszStr - nDist).substr(0, nDist + 20);
     117          60 :     for (int i = static_cast<int>(nDist) - 1; i >= 0; --i)
     118             :     {
     119          55 :         if (osInvalidExpr[i] == '\n')
     120             :         {
     121           0 :             osInvalidExpr = osInvalidExpr.substr(i + 1);
     122           0 :             nDist -= i + 1;
     123           0 :             break;
     124             :         }
     125             :     }
     126          79 :     for (size_t i = nDist; i < osInvalidExpr.size(); ++i)
     127             :     {
     128          74 :         if (osInvalidExpr[i] == '\n')
     129             :         {
     130           0 :             osInvalidExpr.resize(i);
     131           0 :             break;
     132             :         }
     133             :     }
     134           5 :     osErrMsg += osInvalidExpr;
     135           5 :     osErrMsg += "\n";
     136          60 :     for (size_t i = 0; i < nDist; ++i)
     137          55 :         osErrMsg += " ";
     138           5 :     osErrMsg += "^";
     139           5 :     CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrMsg.c_str());
     140           5 : }
     141             : 
     142             : /************************************************************************/
     143             : /*                        SkipSpaces()                                  */
     144             : /************************************************************************/
     145             : 
     146          47 : void GDALGMLJP2Expr::SkipSpaces(const char *&pszStr)
     147             : {
     148          47 :     while (*pszStr == ' ' || *pszStr == '\t' || *pszStr == '\r' ||
     149          39 :            *pszStr == '\n')
     150           8 :         ++pszStr;
     151          39 : }
     152             : 
     153             : /************************************************************************/
     154             : /*                             Build()                                  */
     155             : /************************************************************************/
     156             : 
     157          24 : GDALGMLJP2Expr *GDALGMLJP2Expr::Build(const char *pszOriStr,
     158             :                                       const char *&pszStr)
     159             : {
     160          24 :     if (STARTS_WITH_CI(pszStr, "{{{"))
     161             :     {
     162          12 :         pszStr += strlen("{{{");
     163          12 :         SkipSpaces(pszStr);
     164          12 :         GDALGMLJP2Expr *poExpr = Build(pszOriStr, pszStr);
     165          12 :         if (poExpr == nullptr)
     166           4 :             return nullptr;
     167           8 :         SkipSpaces(pszStr);
     168           8 :         if (!STARTS_WITH_CI(pszStr, "}}}"))
     169             :         {
     170           1 :             ReportError(pszOriStr, pszStr);
     171           1 :             delete poExpr;
     172           1 :             return nullptr;
     173             :         }
     174           7 :         pszStr += strlen("}}}");
     175           7 :         return poExpr;
     176             :     }
     177          12 :     else if (STARTS_WITH_CI(pszStr, "XPATH"))
     178             :     {
     179          10 :         pszStr += strlen("XPATH");
     180          10 :         SkipSpaces(pszStr);
     181          10 :         if (*pszStr != '(')
     182             :         {
     183           1 :             ReportError(pszOriStr, pszStr);
     184           1 :             return nullptr;
     185             :         }
     186           9 :         ++pszStr;
     187           9 :         SkipSpaces(pszStr);
     188          18 :         CPLString l_osValue;
     189           9 :         int nParenthesisIndent = 0;
     190           9 :         char chLiteralQuote = '\0';
     191         138 :         while (*pszStr)
     192             :         {
     193         137 :             if (chLiteralQuote != '\0')
     194             :             {
     195          38 :                 if (*pszStr == chLiteralQuote)
     196           5 :                     chLiteralQuote = '\0';
     197          38 :                 l_osValue += *pszStr;
     198          38 :                 ++pszStr;
     199             :             }
     200          99 :             else if (*pszStr == '\'' || *pszStr == '"')
     201             :             {
     202           5 :                 chLiteralQuote = *pszStr;
     203           5 :                 l_osValue += *pszStr;
     204           5 :                 ++pszStr;
     205             :             }
     206          94 :             else if (*pszStr == '(')
     207             :             {
     208           7 :                 ++nParenthesisIndent;
     209           7 :                 l_osValue += *pszStr;
     210           7 :                 ++pszStr;
     211             :             }
     212          87 :             else if (*pszStr == ')')
     213             :             {
     214          15 :                 nParenthesisIndent--;
     215          15 :                 if (nParenthesisIndent < 0)
     216             :                 {
     217           8 :                     pszStr++;
     218             : #if DEBUG_VERBOSE
     219             :                     CPLDebug("GMLJP2", "XPath expression '%s'",
     220             :                              l_osValue.c_str());
     221             : #endif
     222           8 :                     GDALGMLJP2Expr *poExpr = new GDALGMLJP2Expr();
     223           8 :                     poExpr->eType = GDALGMLJP2ExprType::GDALGMLJP2Expr_XPATH;
     224           8 :                     poExpr->osValue = std::move(l_osValue);
     225           8 :                     return poExpr;
     226             :                 }
     227           7 :                 l_osValue += *pszStr;
     228           7 :                 ++pszStr;
     229             :             }
     230             :             else
     231             :             {
     232          72 :                 l_osValue += *pszStr;
     233          72 :                 pszStr++;
     234             :             }
     235             :         }
     236           1 :         ReportError(pszOriStr, pszStr);
     237           1 :         return nullptr;
     238             :     }
     239             :     else
     240             :     {
     241           2 :         ReportError(pszOriStr, pszStr);
     242           2 :         return nullptr;
     243             :     }
     244             : }
     245             : 
     246             : /************************************************************************/
     247             : /*                       GDALGMLJP2HexFormatter()                       */
     248             : /************************************************************************/
     249             : 
     250          16 : static const char *GDALGMLJP2HexFormatter(GByte nVal)
     251             : {
     252          16 :     return CPLSPrintf("%02X", nVal);
     253             : }
     254             : 
     255             : /************************************************************************/
     256             : /*                            Evaluate()                                */
     257             : /************************************************************************/
     258             : 
     259             : static CPLString GDALGMLJP2EvalExpr(const CPLString &osTemplate,
     260             :                                     xmlXPathContextPtr pXPathCtx,
     261             :                                     xmlDocPtr pDoc);
     262             : 
     263           7 : GDALGMLJP2Expr GDALGMLJP2Expr::Evaluate(xmlXPathContextPtr pXPathCtx,
     264             :                                         xmlDocPtr pDoc)
     265             : {
     266           7 :     switch (eType)
     267             :     {
     268           7 :         case GDALGMLJP2ExprType::GDALGMLJP2Expr_XPATH:
     269             :         {
     270           7 :             xmlXPathObjectPtr pXPathObj = xmlXPathEvalExpression(
     271           7 :                 reinterpret_cast<const xmlChar *>(osValue.c_str()), pXPathCtx);
     272           7 :             if (pXPathObj == nullptr)
     273           2 :                 return GDALGMLJP2Expr("");
     274             : 
     275             :             // Add result of the evaluation.
     276          10 :             CPLString osXMLRes;
     277           5 :             if (pXPathObj->type == XPATH_STRING)
     278           2 :                 osXMLRes = reinterpret_cast<const char *>(pXPathObj->stringval);
     279           3 :             else if (pXPathObj->type == XPATH_BOOLEAN)
     280           1 :                 osXMLRes = pXPathObj->boolval ? "true" : "false";
     281           2 :             else if (pXPathObj->type == XPATH_NUMBER)
     282           1 :                 osXMLRes = CPLSPrintf("%.16g", pXPathObj->floatval);
     283           1 :             else if (pXPathObj->type == XPATH_NODESET)
     284             :             {
     285           1 :                 xmlNodeSetPtr pNodes = pXPathObj->nodesetval;
     286           1 :                 int nNodes = (pNodes) ? pNodes->nodeNr : 0;
     287           2 :                 for (int i = 0; i < nNodes; i++)
     288             :                 {
     289           1 :                     xmlNodePtr pCur = pNodes->nodeTab[i];
     290             : 
     291           1 :                     xmlBufferPtr pBuf = xmlBufferCreate();
     292           1 :                     xmlNodeDump(pBuf, pDoc, pCur, 2, 1);
     293             :                     osXMLRes +=
     294           1 :                         reinterpret_cast<const char *>(xmlBufferContent(pBuf));
     295           1 :                     xmlBufferFree(pBuf);
     296             :                 }
     297             :             }
     298             : 
     299           5 :             xmlXPathFreeObject(pXPathObj);
     300           5 :             return GDALGMLJP2Expr(osXMLRes);
     301             :         }
     302           0 :         default:
     303           0 :             CPLAssert(false);
     304             :             return GDALGMLJP2Expr("");
     305             :     }
     306             : }
     307             : 
     308             : /************************************************************************/
     309             : /*                        GDALGMLJP2EvalExpr()                          */
     310             : /************************************************************************/
     311             : 
     312           8 : static CPLString GDALGMLJP2EvalExpr(const CPLString &osTemplate,
     313             :                                     xmlXPathContextPtr pXPathCtx,
     314             :                                     xmlDocPtr pDoc)
     315             : {
     316           8 :     CPLString osXMLRes;
     317           8 :     size_t nPos = 0;
     318             :     while (true)
     319             :     {
     320             :         // Get next expression.
     321          15 :         size_t nStartPos = osTemplate.find("{{{", nPos);
     322          15 :         if (nStartPos == std::string::npos)
     323             :         {
     324             :             // Add terminating portion of the template.
     325           3 :             osXMLRes += osTemplate.substr(nPos);
     326           3 :             break;
     327             :         }
     328             : 
     329             :         // Add portion of template before the expression.
     330          12 :         osXMLRes += osTemplate.substr(nPos, nStartPos - nPos);
     331             : 
     332          12 :         const char *pszExpr = osTemplate.c_str() + nStartPos;
     333          12 :         GDALGMLJP2Expr *poExpr = GDALGMLJP2Expr::Build(pszExpr, pszExpr);
     334          12 :         if (poExpr == nullptr)
     335           5 :             break;
     336           7 :         nPos = static_cast<size_t>(pszExpr - osTemplate.c_str());
     337           7 :         osXMLRes += poExpr->Evaluate(pXPathCtx, pDoc).osValue;
     338           7 :         delete poExpr;
     339           7 :     }
     340           8 :     return osXMLRes;
     341             : }
     342             : 
     343             : /************************************************************************/
     344             : /*                      GDALGMLJP2XPathErrorHandler()                   */
     345             : /************************************************************************/
     346             : 
     347           2 : static void GDALGMLJP2XPathErrorHandler(void * /* userData */,
     348             : #if LIBXML_VERSION >= 21200
     349             :                                         const xmlError *error
     350             : #else
     351             :                                         xmlErrorPtr error
     352             : #endif
     353             : )
     354             : {
     355           2 :     if (error->domain == XML_FROM_XPATH && error->str1 != nullptr &&
     356           2 :         error->int1 < static_cast<int>(strlen(error->str1)))
     357             :     {
     358           0 :         GDALGMLJP2Expr::ReportError(error->str1, error->str1 + error->int1,
     359             :                                     "XPath error:\n");
     360             :     }
     361             :     else
     362             :     {
     363           2 :         CPLError(CE_Failure, CPLE_AppDefined, "An error occurred in libxml2");
     364             :     }
     365           2 : }
     366             : 
     367             : /************************************************************************/
     368             : /*                    GDALGMLJP2RegisterNamespaces()                    */
     369             : /************************************************************************/
     370             : 
     371          28 : static void GDALGMLJP2RegisterNamespaces(xmlXPathContextPtr pXPathCtx,
     372             :                                          xmlNode *pNode)
     373             : {
     374          28 :     for (; pNode; pNode = pNode->next)
     375             :     {
     376          10 :         if (pNode->type == XML_ELEMENT_NODE)
     377             :         {
     378           9 :             if (pNode->ns != nullptr && pNode->ns->prefix != nullptr)
     379             :             {
     380             :                 // printf("%s %s\n",pNode->ns->prefix, pNode->ns->href);
     381           0 :                 if (xmlXPathRegisterNs(pXPathCtx, pNode->ns->prefix,
     382           0 :                                        pNode->ns->href) != 0)
     383             :                 {
     384           0 :                     CPLError(CE_Warning, CPLE_AppDefined,
     385             :                              "Registration of namespace %s failed",
     386           0 :                              reinterpret_cast<const char *>(pNode->ns->prefix));
     387             :                 }
     388             :             }
     389             :         }
     390             : 
     391          10 :         GDALGMLJP2RegisterNamespaces(pXPathCtx, pNode->children);
     392             :     }
     393          18 : }
     394             : 
     395             : /************************************************************************/
     396             : /*                         GDALGMLJP2XPathIf()                          */
     397             : /************************************************************************/
     398             : 
     399           2 : static void GDALGMLJP2XPathIf(xmlXPathParserContextPtr ctxt, int nargs)
     400             : {
     401             :     xmlXPathObjectPtr cond_val, then_val, else_val;
     402             : 
     403           2 :     CHECK_ARITY(3);
     404           2 :     else_val = valuePop(ctxt);
     405           2 :     then_val = valuePop(ctxt);
     406           2 :     CAST_TO_BOOLEAN
     407           2 :     cond_val = valuePop(ctxt);
     408             : 
     409           2 :     if (cond_val->boolval)
     410             :     {
     411           1 :         xmlXPathFreeObject(else_val);
     412           1 :         valuePush(ctxt, then_val);
     413             :     }
     414             :     else
     415             :     {
     416           1 :         xmlXPathFreeObject(then_val);
     417           1 :         valuePush(ctxt, else_val);
     418             :     }
     419           2 :     xmlXPathFreeObject(cond_val);
     420             : }
     421             : 
     422             : /************************************************************************/
     423             : /*                        GDALGMLJP2XPathUUID()                         */
     424             : /************************************************************************/
     425             : 
     426           1 : static void GDALGMLJP2XPathUUID(xmlXPathParserContextPtr ctxt, int nargs)
     427             : {
     428           1 :     CHECK_ARITY(0);
     429             : 
     430           2 :     CPLString osRet;
     431             : 
     432             :     // From POSIX.1-2001 as an example of an implementation of rand()
     433          16 :     const auto fakeRand = []()
     434             :     {
     435             :         static uint32_t nCounter =
     436          16 :             static_cast<unsigned int>(time(nullptr) & UINT_MAX);
     437          16 :         uint32_t nCounterLocal = static_cast<uint32_t>(
     438          16 :             (static_cast<uint64_t>(nCounter) * 1103515245U + 12345U) &
     439             :             UINT32_MAX);
     440          16 :         nCounter = nCounterLocal;
     441          16 :         return (nCounterLocal / 65536U) % 32768U;
     442             :     };
     443             : 
     444           5 :     for (int i = 0; i < 4; i++)
     445           4 :         osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     446           1 :     osRet += "-";
     447           1 :     osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     448           1 :     osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     449           1 :     osRet += "-";
     450             :     // Set the version number bits (4 == random).
     451           1 :     osRet += GDALGMLJP2HexFormatter((fakeRand() & 0x0F) | 0x40);
     452           1 :     osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     453           1 :     osRet += "-";
     454             :     // Set the variant bits.
     455           1 :     osRet += GDALGMLJP2HexFormatter((fakeRand() & 0x3F) | 0x80);
     456           1 :     osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     457           1 :     osRet += "-";
     458           7 :     for (int i = 0; i < 6; ++i)
     459             :     {
     460           6 :         osRet += GDALGMLJP2HexFormatter(fakeRand() & 0xFF);
     461             :     }
     462             : 
     463           1 :     valuePush(ctxt, xmlXPathNewString(
     464           1 :                         reinterpret_cast<const xmlChar *>(osRet.c_str())));
     465             : }
     466             : 
     467             : #endif  // LIBXML2
     468             : 
     469             : /************************************************************************/
     470             : /*                      GDALGMLJP2GenerateMetadata()                    */
     471             : /************************************************************************/
     472             : 
     473             : #ifdef HAVE_LIBXML2
     474          11 : CPLXMLNode *GDALGMLJP2GenerateMetadata(const CPLString &osTemplateFile,
     475             :                                        const CPLString &osSourceFile)
     476             : {
     477          11 :     GByte *pabyStr = nullptr;
     478          11 :     if (!VSIIngestFile(nullptr, osTemplateFile, &pabyStr, nullptr, -1))
     479           1 :         return nullptr;
     480          20 :     CPLString osTemplate(reinterpret_cast<char *>(pabyStr));
     481          10 :     CPLFree(pabyStr);
     482             : 
     483          10 :     if (!VSIIngestFile(nullptr, osSourceFile, &pabyStr, nullptr, -1))
     484           1 :         return nullptr;
     485          18 :     CPLString osSource(reinterpret_cast<char *>(pabyStr));
     486           9 :     CPLFree(pabyStr);
     487             : 
     488             :     xmlDocPtr pDoc =
     489           9 :         xmlParseDoc(reinterpret_cast<const xmlChar *>(osSource.c_str()));
     490           9 :     if (pDoc == nullptr)
     491             :     {
     492           1 :         CPLError(CE_Failure, CPLE_AppDefined, "Cannot parse %s",
     493             :                  osSourceFile.c_str());
     494           1 :         return nullptr;
     495             :     }
     496             : 
     497           8 :     xmlXPathContextPtr pXPathCtx = xmlXPathNewContext(pDoc);
     498           8 :     if (pXPathCtx == nullptr)
     499             :     {
     500           0 :         xmlFreeDoc(pDoc);
     501           0 :         return nullptr;
     502             :     }
     503             : 
     504           8 :     xmlXPathRegisterFunc(pXPathCtx, reinterpret_cast<const xmlChar *>("if"),
     505             :                          GDALGMLJP2XPathIf);
     506           8 :     xmlXPathRegisterFunc(pXPathCtx, reinterpret_cast<const xmlChar *>("uuid"),
     507             :                          GDALGMLJP2XPathUUID);
     508             : 
     509           8 :     pXPathCtx->error = GDALGMLJP2XPathErrorHandler;
     510             : 
     511           8 :     GDALGMLJP2RegisterNamespaces(pXPathCtx, xmlDocGetRootElement(pDoc));
     512             : 
     513          16 :     CPLString osXMLRes = GDALGMLJP2EvalExpr(osTemplate, pXPathCtx, pDoc);
     514             : 
     515           8 :     xmlXPathFreeContext(pXPathCtx);
     516           8 :     xmlFreeDoc(pDoc);
     517             : 
     518           8 :     return CPLParseXMLString(osXMLRes);
     519             : }
     520             : #else   // !HAVE_LIBXML2
     521             : CPLXMLNode *GDALGMLJP2GenerateMetadata(const CPLString & /* osTemplateFile */,
     522             :                                        const CPLString & /* osSourceFile */
     523             : )
     524             : {
     525             :     return nullptr;
     526             : }
     527             : #endif  // HAVE_LIBXML2