/**********************************************************************

* $Id$

*

* Project: MapServer

* Purpose: OGC SLD implementation

* Author: Y. Assefa, DM Solutions Group (assefa@dmsolutions.ca)

*

**********************************************************************

* Copyright (c) 2003, Y. Assefa, DM Solutions Group Inc

*

* 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

****************************************************************************/

#include "mapogcsld.h"

#include "mapogcfilter.h"

#include "mapserver.h"

#include "mapows.h"

#include "mapcopy.h"

#include "cpl_string.h"

extern "C" {

extern int yyparse(parseObj *);

}

static inline void IGUR_sizet(size_t ignored) {

(void)ignored;

} /* Ignore GCC Unused Result */

#define SLD_LINE_SYMBOL_NAME "sld_line_symbol"

#define SLD_LINE_SYMBOL_DASH_NAME "sld_line_symbol_dash"

#define SLD_MARK_SYMBOL_SQUARE "sld_mark_symbol_square"

#define SLD_MARK_SYMBOL_SQUARE_FILLED "sld_mark_symbol_square_filled"

#define SLD_MARK_SYMBOL_CIRCLE "sld_mark_symbol_circle"

#define SLD_MARK_SYMBOL_CIRCLE_FILLED "sld_mark_symbol_circle_filled"

#define SLD_MARK_SYMBOL_TRIANGLE "sld_mark_symbol_triangle"

#define SLD_MARK_SYMBOL_TRIANGLE_FILLED "sld_mark_symbol_triangle_filled"

#define SLD_MARK_SYMBOL_STAR "sld_mark_symbol_star"

#define SLD_MARK_SYMBOL_STAR_FILLED "sld_mark_symbol_star_filled"

#define SLD_MARK_SYMBOL_CROSS "sld_mark_symbol_cross"

#define SLD_MARK_SYMBOL_CROSS_FILLED "sld_mark_symbol_cross_filled"

#define SLD_MARK_SYMBOL_X "sld_mark_symbol_x"

#define SLD_MARK_SYMBOL_X_FILLED "sld_mark_symbol_x_filled"

/************************************************************************/

/* msSLDApplySLDURL */

/* */

/* Use the SLD document given through a URL and apply the SLD */

/* on the map. Layer name and Named Layer's name parameter are */

/* used to do the match. */

/************************************************************************/

int msSLDApplySLDURL(mapObj *map, const char *szURL, int iLayer,

const char *pszStyleLayerName, char **ppszLayerNames) {

/* needed for libcurl function msHTTPGetFile in maphttp.c */

#if defined(USE_CURL)

char *pszSLDTmpFile = NULL;

int status = 0;

char *pszSLDbuf = NULL;

FILE *fp = NULL;

int nStatus = MS_FAILURE;

if (map && szURL) {

map->sldurl = (char *)szURL;

pszSLDTmpFile = msTmpFile(map, map->mappath, NULL, "sld.xml");

if (pszSLDTmpFile == NULL) {

pszSLDTmpFile = msTmpFile(map, NULL, NULL, "sld.xml");

}

if (pszSLDTmpFile == NULL) {

msSetError(

MS_WMSERR,

"Could not determine temporary file. Please make sure that the "

"temporary path is set. The temporary path can be defined for "

"example by setting TEMPPATH in the map file. Please check the "

"MapServer documentation on temporary path settings.",

"msSLDApplySLDURL()");

} else {

int nMaxRemoteSLDBytes;

const char *pszMaxRemoteSLDBytes = msOWSLookupMetadata(

&(map->web.metadata), "MO", "remote_sld_max_bytes");

if (!pszMaxRemoteSLDBytes) {

nMaxRemoteSLDBytes = 1024 * 1024; /* 1 megaByte */

} else {

nMaxRemoteSLDBytes = atoi(pszMaxRemoteSLDBytes);

}

if (msHTTPGetFile(szURL, pszSLDTmpFile, &status, -1, 0, 0,

nMaxRemoteSLDBytes) == MS_SUCCESS) {

if ((fp = fopen(pszSLDTmpFile, "rb")) != NULL) {

int nBufsize = 0;

fseek(fp, 0, SEEK_END);

nBufsize = ftell(fp);

if (nBufsize > 0) {

rewind(fp);

pszSLDbuf = (char *)malloc((nBufsize + 1) * sizeof(char));

if (pszSLDbuf == NULL) {

msSetError(MS_MEMERR, "Failed to open SLD file.",

"msSLDApplySLDURL()");

} else {

IGUR_sizet(fread(pszSLDbuf, 1, nBufsize, fp));

pszSLDbuf[nBufsize] = '\0';

}

} else {

msSetError(MS_WMSERR, "Could not open SLD %s as it appears empty",

"msSLDApplySLDURL", szURL);

}

fclose(fp);

unlink(pszSLDTmpFile);

}

} else {

unlink(pszSLDTmpFile);

msSetError(

MS_WMSERR,

"Could not open SLD %s and save it in a temporary file. Please "

"make sure that the sld url is valid and that the temporary path "

"is set. The temporary path can be defined for example by setting "

"TEMPPATH in the map file. Please check the MapServer "

"documentation on temporary path settings.",

"msSLDApplySLDURL", szURL);

}

msFree(pszSLDTmpFile);

if (pszSLDbuf)

nStatus = msSLDApplySLD(map, pszSLDbuf, iLayer, pszStyleLayerName,

ppszLayerNames);

}

map->sldurl = NULL;

}

msFree(pszSLDbuf);

return nStatus;

#else

msSetError(MS_MISCERR, "WMS/WFS client support is not enabled .",

"msSLDApplySLDURL()");

return (MS_FAILURE);

#endif

}

/************************************************************************/

/* msSLDApplyFromFile */

/* */

/* Apply SLD from a file on disk to the layerObj */

/************************************************************************/

int msSLDApplyFromFile(mapObj *map, layerObj *layer, const char *filename) {

FILE *fp = NULL;

int nStatus = MS_FAILURE;

/* open SLD file */

char szPath[MS_MAXPATHLEN];

char *pszSLDbuf = NULL;

const char *realpath = msBuildPath(szPath, map->mappath, filename);

if ((fp = fopen(realpath, "rb")) != NULL) {

int nBufsize = 0;

fseek(fp, 0, SEEK_END);

nBufsize = ftell(fp);

if (nBufsize > 0) {

rewind(fp);

pszSLDbuf = (char *)malloc((nBufsize + 1) * sizeof(char));

if (pszSLDbuf == NULL) {

msSetError(MS_MEMERR, "Failed to read SLD file.",

"msSLDApplyFromFile()");

} else {

IGUR_sizet(fread(pszSLDbuf, 1, nBufsize, fp));

pszSLDbuf[nBufsize] = '\0';

}

} else {

msSetError(MS_IOERR, "Could not open SLD %s as it appears empty",

"msSLDApplyFromFile", realpath);

}

fclose(fp);

}

if (pszSLDbuf) {

// if not set, then use the first NamedStyle in the SLD file

// even if the names don't match

const char *pszMetadataName = "SLD_USE_FIRST_NAMEDLAYER";

const char *pszValue =

msLookupHashTable(&(layer->metadata), pszMetadataName);

if (pszValue == NULL) {

msInsertHashTable(&(layer->metadata), pszMetadataName, "true");

}

nStatus = msSLDApplySLD(map, pszSLDbuf, layer->index, NULL, NULL);

} else {

msSetError(MS_IOERR, "Invalid SLD filename: \"%s\".",

"msSLDApplyFromFile()", realpath);

}

msFree(pszSLDbuf);

return nStatus;

}

#if defined(USE_WMS_SVR) || defined(USE_WFS_SVR) || defined(USE_WCS_SVR) || \

defined(USE_SOS_SVR)

/* -------------------------------------------------------------------- */

/* If the same layer is given more that once, we need to */

/* duplicate it. */

/* -------------------------------------------------------------------- */

static void msSLDApplySLD_DuplicateLayers(mapObj *map, int nSLDLayers,

layerObj *pasSLDLayers) {

int m;

for (m = 0; m < nSLDLayers; m++) {

int l;

int nIndex = msGetLayerIndex(map, pasSLDLayers[m].name);

if (pasSLDLayers[m].name == NULL)

continue;

if (nIndex < 0)

continue;

for (l = m + 1; l < nSLDLayers; l++) {

if (pasSLDLayers[l].name == NULL)

continue;

if (strcasecmp(pasSLDLayers[m].name, pasSLDLayers[l].name) == 0) {

layerObj *psTmpLayer = (layerObj *)malloc(sizeof(layerObj));

char tmpId[128];

initLayer(psTmpLayer, map);

msCopyLayer(psTmpLayer, GET_LAYER(map, nIndex));

/* open the source layer */

if (!psTmpLayer->vtable) {

if (msInitializeVirtualTable(psTmpLayer) != MS_SUCCESS) {

MS_REFCNT_DECR(psTmpLayer);

continue;

}

}

/*make the name unique*/

snprintf(tmpId, sizeof(tmpId), "%lx_%x_%d", (long)time(NULL),

(int)getpid(), map->numlayers);

if (psTmpLayer->name)

msFree(psTmpLayer->name);

psTmpLayer->name = msStrdup(tmpId);

msFree(pasSLDLayers[l].name);

pasSLDLayers[l].name = msStrdup(tmpId);

msInsertLayer(map, psTmpLayer, -1);

MS_REFCNT_DECR(psTmpLayer);

}

}

}

}

#endif

static int msApplySldLayerToMapLayer(layerObj *sldLayer, layerObj *lp) {

if (sldLayer->numclasses > 0) {

int iClass = 0;

bool bSLDHasNamedClass = false;

lp->type = sldLayer->type;

lp->rendermode = MS_ALL_MATCHING_CLASSES;

for (int k = 0; k < sldLayer->numclasses; k++) {

if (sldLayer->_class[k]->group) {

bSLDHasNamedClass = true;

break;

}

}

for (int k = 0; k < lp->numclasses; k++) {

if (lp->_class[k] != NULL) {

lp->_class[k]->layer = NULL;

if (freeClass(lp->_class[k]) == MS_SUCCESS) {

msFree(lp->_class[k]);

lp->_class[k] = NULL;

}

}

}

lp->numclasses = 0;

if (bSLDHasNamedClass && sldLayer->classgroup) {

/* Set the class group to the class that has UserStyle.IsDefaultf

*/

msFree(lp->classgroup);

lp->classgroup = msStrdup(sldLayer->classgroup);

} else {

/*unset the classgroup on the layer if it was set. This allows the

layer to render with all the classes defined in the SLD*/

msFree(lp->classgroup);

lp->classgroup = NULL;

}

for (int k = 0; k < sldLayer->numclasses; k++) {

if (msGrowLayerClasses(lp) == NULL)

return MS_FAILURE;

initClass(lp->_class[iClass]);

msCopyClass(lp->_class[iClass], sldLayer->_class[k], NULL);

lp->_class[iClass]->layer = lp;

lp->numclasses++;

/*aliases may have been used as part of the sld text symbolizer

for label element. Try to process it if that is the case #3114*/

const int layerWasOpened = msLayerIsOpen(lp);

if (layerWasOpened || (msLayerOpen(lp) == MS_SUCCESS &&

msLayerGetItems(lp) == MS_SUCCESS)) {

if (lp->_class[iClass]->text.string) {

for (int z = 0; z < lp->numitems; z++) {

if (!lp->items[z] || strlen(lp->items[z]) == 0)

continue;

char *pszTmp1 = msStrdup(lp->_class[iClass]->text.string);

const char *pszFullName = msOWSLookupMetadata(

&(lp->metadata), "G",

std::string(lp->items[z]).append("_alias").c_str());

if (pszFullName != NULL && (strstr(pszTmp1, pszFullName) != NULL)) {

pszTmp1 = msReplaceSubstring(pszTmp1, pszFullName, lp->items[z]);

std::string osTmp("(");

osTmp.append(pszTmp1).append(")");

// Silence false positive Coverity Scan warnings which wrongly

// believes that osTmp.c_str() might be used by

// msLoadExpressionString() after osTmp is destroyed.

// coverity[escape]

msLoadExpressionString(&(lp->_class[iClass]->text),

osTmp.c_str());

}

msFree(pszTmp1);

}

}

if (!layerWasOpened) { // don't close the layer if already

// open

msLayerClose(lp);

}

}

iClass++;

}

} else {

/*this is probably an SLD that uses Named styles*/

if (sldLayer->classgroup) {

int k;

for (k = 0; k < lp->numclasses; k++) {

if (lp->_class[k]->group &&

strcasecmp(lp->_class[k]->group, sldLayer->classgroup) == 0)

break;

}

if (k < lp->numclasses) {

msFree(lp->classgroup);

lp->classgroup = msStrdup(sldLayer->classgroup);

} else {

/* TODO we throw an exception ?*/

}

}

}

if (sldLayer->labelitem) {

if (lp->labelitem)

free(lp->labelitem);

lp->labelitem = msStrdup(sldLayer->labelitem);

}

if (sldLayer->classitem) {

if (lp->classitem)

free(lp->classitem);

lp->classitem = msStrdup(sldLayer->classitem);

}

/* opacity for sld raster */

if (lp->type == MS_LAYER_RASTER && sldLayer->compositer &&

sldLayer->compositer->opacity != 100)

msSetLayerOpacity(lp, sldLayer->compositer->opacity);

/* mark as auto-generate SLD */

if (lp->connectiontype == MS_WMS)

msInsertHashTable(&(lp->metadata), "wms_sld_body", "auto");

/* The SLD might have a FeatureTypeConstraint */

if (sldLayer->filter.type == MS_EXPRESSION) {

if (lp->filter.string && lp->filter.type == MS_EXPRESSION) {

char *pszBuffer = msStringConcatenate(NULL, "((");

pszBuffer = msStringConcatenate(pszBuffer, lp->filter.string);

pszBuffer = msStringConcatenate(pszBuffer, ") AND (");

pszBuffer = msStringConcatenate(pszBuffer, sldLayer->filter.string);

pszBuffer = msStringConcatenate(pszBuffer, "))");

msFreeExpression(&lp->filter);

msInitExpression(&lp->filter);

lp->filter.string = pszBuffer;

lp->filter.type = MS_EXPRESSION;

} else {

msFreeExpression(&lp->filter);

msInitExpression(&lp->filter);

lp->filter.string = msStrdup(sldLayer->filter.string);

lp->filter.type = MS_EXPRESSION;

}

}

/*in some cases it would make sense to concatenate all the class

expressions and use it to set the filter on the layer. This

could increase performance. Will do it for db types layers

#2840*/

if (lp->filter.string == NULL ||

(lp->filter.string && lp->filter.type == MS_STRING && !lp->filteritem)) {

if (lp->connectiontype == MS_POSTGIS ||

lp->connectiontype == MS_ORACLESPATIAL ||

lp->connectiontype == MS_PLUGIN) {

if (lp->numclasses > 0) {

/* check first that all classes have an expression type.

That is the only way we can concatenate them and set the

filter expression */

int k;

for (k = 0; k < lp->numclasses; k++) {

if (lp->_class[k]->expression.type != MS_EXPRESSION)

break;

}

if (k == lp->numclasses) {

char szTmp[512];

char *pszBuffer = NULL;

for (k = 0; k < lp->numclasses; k++) {

if (pszBuffer == NULL)

snprintf(szTmp, sizeof(szTmp), "%s",

"(("); /* we a building a string expression,

explicitly set type below */

else

snprintf(szTmp, sizeof(szTmp), "%s", " OR ");

pszBuffer = msStringConcatenate(pszBuffer, szTmp);

pszBuffer = msStringConcatenate(pszBuffer,

lp->_class[k]->expression.string);

}

snprintf(szTmp, sizeof(szTmp), "%s", "))");

pszBuffer = msStringConcatenate(pszBuffer, szTmp);

msFreeExpression(&lp->filter);

msInitExpression(&lp->filter);

lp->filter.string = msStrdup(pszBuffer);

lp->filter.type = MS_EXPRESSION;

msFree(pszBuffer);

}

}

}

}

return MS_SUCCESS;

}

/************************************************************************/

/* msSLDApplySLD */

/* */

/* Parses the SLD into array of layers. Go through the map and */

/* compare the SLD layers and the map layers using the name. If */

/* they have the same name, copy the classes associated with */

/* the SLD layers onto the map layers. */

/************************************************************************/

int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer,

const char *pszStyleLayerName, char **ppszLayerNames) {

#if defined(USE_WMS_SVR) || defined(USE_WFS_SVR) || defined(USE_WCS_SVR) || \

defined(USE_SOS_SVR)

int nSLDLayers = 0;

layerObj *pasSLDLayers = NULL;

int nStatus = MS_SUCCESS;

/*const char *pszSLDNotSupported = NULL;*/

pasSLDLayers = msSLDParseSLD(map, psSLDXML, &nSLDLayers);

if (pasSLDLayers == NULL) {

errorObj *psError = msGetErrorObj();

if (psError && psError->code != MS_NOERR)

return MS_FAILURE;

}

if (pasSLDLayers && nSLDLayers > 0) {

int i;

msSLDApplySLD_DuplicateLayers(map, nSLDLayers, pasSLDLayers);

for (i = 0; i < map->numlayers; i++) {

layerObj *lp = NULL;

const char *pszWMSLayerName = NULL;

int j;

int bUseSpecificLayer = 0;

if (iLayer >= 0 && iLayer < map->numlayers) {

i = iLayer;

bUseSpecificLayer = 1;

}

lp = GET_LAYER(map, i);

/* compare layer name to wms_name as well */

pszWMSLayerName = msOWSLookupMetadata(&(lp->metadata), "MO", "name");

bool bSldApplied = false;

for (j = 0; j < nSLDLayers; j++) {

layerObj *sldLayer = &pasSLDLayers[j];

/* --------------------------------------------------------------------

*/

/* copy : - class */

/* - layer's labelitem */

/* --------------------------------------------------------------------

*/

if ((sldLayer->name && pszStyleLayerName == NULL &&

((strcasecmp(lp->name, sldLayer->name) == 0 ||

(pszWMSLayerName &&

strcasecmp(pszWMSLayerName, sldLayer->name) == 0)) ||

(lp->group && strcasecmp(lp->group, sldLayer->name) == 0))) ||

(bUseSpecificLayer && pszStyleLayerName && sldLayer->name &&

strcasecmp(sldLayer->name, pszStyleLayerName) == 0)) {

#ifdef notdef

/*this is a test code if we decide to flag some layers as not

* supporting SLD*/

pszSLDNotSupported =

msOWSLookupMetadata(&(lp->metadata), "M", "SLD_NOT_SUPPORTED");

if (pszSLDNotSupported) {

msSetError(MS_WMSERR, "Layer %s does not support SLD",

"msSLDApplySLD", sldLayer->name);

nsStatus = MS_FAILURE;

goto sld_cleanup;

}

#endif

if (msApplySldLayerToMapLayer(sldLayer, lp) == MS_FAILURE) {

nStatus = MS_FAILURE;

goto sld_cleanup;

};

bSldApplied = true;

break;

}

}

if (bUseSpecificLayer) {

if (!bSldApplied) {

// there was no name match between the map layer and the SLD named

// layer - check if we should apply the first SLD layer anyway

const char *pszSLDUseFirstNamedLayer =

msLookupHashTable(&(lp->metadata), "SLD_USE_FIRST_NAMEDLAYER");

if (pszSLDUseFirstNamedLayer) {

if (strcasecmp(pszSLDUseFirstNamedLayer, "true") == 0) {

layerObj *firstSldLayer = &pasSLDLayers[0];

if (msApplySldLayerToMapLayer(firstSldLayer, lp) == MS_FAILURE) {

nStatus = MS_FAILURE;

goto sld_cleanup;

};

}

}

}

break;

}

}

/* -------------------------------------------------------------------- */

/* if needed return a comma separated list of the layers found */

/* in the sld. */

/* -------------------------------------------------------------------- */

if (ppszLayerNames) {

char *pszTmp = NULL;

for (i = 0; i < nSLDLayers; i++) {

if (pasSLDLayers[i].name) {

if (pszTmp != NULL)

pszTmp = msStringConcatenate(pszTmp, ",");

pszTmp = msStringConcatenate(pszTmp, pasSLDLayers[i].name);

}

}

*ppszLayerNames = pszTmp;

}

}

nStatus = MS_SUCCESS;

sld_cleanup:

if (pasSLDLayers) {

for (int i = 0; i < nSLDLayers; i++)

freeLayer(&pasSLDLayers[i]);

msFree(pasSLDLayers);

}

if (map->debug == MS_DEBUGLEVEL_VVV) {

char *tmpfilename = msTmpFile(map, map->mappath, NULL, "_sld.map");

if (tmpfilename == NULL) {

tmpfilename = msTmpFile(map, NULL, NULL, "_sld.map");

}

if (tmpfilename) {

msSaveMap(map, tmpfilename);

msDebug("msApplySLD(): Map file after SLD was applied %s\n", tmpfilename);

msFree(tmpfilename);

}

}

return nStatus;

#else

msSetError(MS_MISCERR, "OWS support is not available.", "msSLDApplySLD()");

return (MS_FAILURE);

#endif

}

static CPLXMLNode *FindNextChild(CPLXMLNode *psNode, const char *pszChildName) {

while (psNode) {

if (psNode->eType == CXT_Element &&

strcasecmp(psNode->pszValue, pszChildName) == 0) {

return psNode;

}

psNode = psNode->psNext;

}

return NULL;

}

#define LOOP_ON_CHILD_ELEMENT(psParent_, psChild_, pszChildName_) \

for (psChild_ = FindNextChild(psParent_->psChild, pszChildName_); \

psChild_ != NULL; \

psChild_ = FindNextChild(psChild_->psNext, pszChildName_))

/************************************************************************/

/* msSLDParseSLD */

/* */

/* Parse the sld document into layers : for each named layer */

/* there is one mapserver layer created with appropriate */

/* classes and styles. */

/* Returns an array of mapserver layers. The pnLayres if */

/* provided will indicate the size of the returned array. */

/************************************************************************/

layerObj *msSLDParseSLD(mapObj *map, const char *psSLDXML, int *pnLayers) {

CPLXMLNode *psRoot = NULL;

CPLXMLNode *psSLD, *psNamedLayer;

layerObj *pasLayers = NULL;

int iLayer = 0;

int nLayers = 0;

if (map == NULL || psSLDXML == NULL || strlen(psSLDXML) == 0 ||

(strstr(psSLDXML, "StyledLayerDescriptor") == NULL)) {

msSetError(MS_WMSERR, "Invalid SLD document", "");

return NULL;

}

psRoot = CPLParseXMLString(psSLDXML);

if (psRoot == NULL) {

msSetError(MS_WMSERR, "Invalid SLD document : %s", "", psSLDXML);

return NULL;

}

/* strip namespaces ogc and sld and gml */

CPLStripXMLNamespace(psRoot, "ogc", 1);

CPLStripXMLNamespace(psRoot, "sld", 1);

CPLStripXMLNamespace(psRoot, "gml", 1);

CPLStripXMLNamespace(psRoot, "se", 1);

/* -------------------------------------------------------------------- */

/* get the root element (StyledLayerDescriptor). */

/* -------------------------------------------------------------------- */

psSLD = CPLGetXMLNode(psRoot, "=StyledLayerDescriptor");

if (!psSLD) {

msSetError(MS_WMSERR, "Invalid SLD document : %s", "", psSLDXML);

return NULL;

}

/* -------------------------------------------------------------------- */

/* Parse the named layers. */

/* -------------------------------------------------------------------- */

LOOP_ON_CHILD_ELEMENT(psSLD, psNamedLayer, "NamedLayer") { nLayers++; }

if (nLayers > 0)

pasLayers = (layerObj *)malloc(sizeof(layerObj) * nLayers);

else

return NULL;

LOOP_ON_CHILD_ELEMENT(psSLD, psNamedLayer, "NamedLayer") {

CPLXMLNode *psName = CPLGetXMLNode(psNamedLayer, "Name");

initLayer(&pasLayers[iLayer], map);

if (psName && psName->psChild && psName->psChild->pszValue)

pasLayers[iLayer].name = msStrdup(psName->psChild->pszValue);

if (msSLDParseNamedLayer(psNamedLayer, &pasLayers[iLayer]) != MS_SUCCESS) {

int i;

for (i = 0; i <= iLayer; i++)

freeLayer(&pasLayers[i]);

msFree(pasLayers);

nLayers = 0;

pasLayers = NULL;

break;

}

iLayer++;

}

if (pnLayers)

*pnLayers = nLayers;

if (psRoot)

CPLDestroyXMLNode(psRoot);

return pasLayers;

}

/************************************************************************/

/* _SLDApplyRuleValues */

/* */

/* Utility function to set the scale, title/name for the */

/* classes created by a Rule. */

/************************************************************************/

void _SLDApplyRuleValues(CPLXMLNode *psRule, layerObj *psLayer,

int nNewClasses) {

CPLXMLNode *psMinScale = NULL, *psMaxScale = NULL;

CPLXMLNode *psName = NULL, *psTitle = NULL;

double dfMinScale = 0, dfMaxScale = 0;

char *pszName = NULL, *pszTitle = NULL;

if (psRule && psLayer && nNewClasses > 0) {

/* -------------------------------------------------------------------- */

/* parse minscale and maxscale. */

/* -------------------------------------------------------------------- */

psMinScale = CPLGetXMLNode(psRule, "MinScaleDenominator");

if (psMinScale && psMinScale->psChild && psMinScale->psChild->pszValue)

dfMinScale = atof(psMinScale->psChild->pszValue);

psMaxScale = CPLGetXMLNode(psRule, "MaxScaleDenominator");

if (psMaxScale && psMaxScale->psChild && psMaxScale->psChild->pszValue)

dfMaxScale = atof(psMaxScale->psChild->pszValue);

/* -------------------------------------------------------------------- */

/* parse name and title. */

/* -------------------------------------------------------------------- */

psName = CPLGetXMLNode(psRule, "Name");

if (psName && psName->psChild && psName->psChild->pszValue)

pszName = psName->psChild->pszValue;

psTitle = CPLGetXMLNode(psRule, "Title");

if (psTitle && psTitle->psChild && psTitle->psChild->pszValue)

pszTitle = psTitle->psChild->pszValue;

/* -------------------------------------------------------------------- */

/* set the scale to all the classes created by the rule. */

/* -------------------------------------------------------------------- */

if (dfMinScale > 0 || dfMaxScale > 0) {

for (int i = 0; i < nNewClasses; i++) {

if (dfMinScale > 0)

psLayer->_class[psLayer->numclasses - 1 - i]->minscaledenom =

dfMinScale;

if (dfMaxScale)

psLayer->_class[psLayer->numclasses - 1 - i]->maxscaledenom =

dfMaxScale;

}

}

/* -------------------------------------------------------------------- */

/* set name and title to the classes created by the rule. */

/* -------------------------------------------------------------------- */

for (int i = 0; i < nNewClasses; i++) {

if (!psLayer->_class[psLayer->numclasses - 1 - i]->name) {

if (pszName)

psLayer->_class[psLayer->numclasses - 1 - i]->name =

msStrdup(pszName);

else if (pszTitle)

psLayer->_class[psLayer->numclasses - 1 - i]->name =

msStrdup(pszTitle);

else {

// Build a name from layer and class info

char szTmp[256];

snprintf(szTmp, sizeof(szTmp), "%s#%d", psLayer->name,

psLayer->numclasses - 1 - i);

psLayer->_class[psLayer->numclasses - 1 - i]->name = msStrdup(szTmp);

}

}

}

if (pszTitle) {

for (int i = 0; i < nNewClasses; i++) {

psLayer->_class[psLayer->numclasses - 1 - i]->title =

msStrdup(pszTitle);

}

}

}

}

/************************************************************************/

/* msSLDGetCommonExpressionFromFilter */

/* */

/* Get a common expression valid from the filter valid for the */

/* temporary layer. */

/************************************************************************/

static char *msSLDGetCommonExpressionFromFilter(CPLXMLNode *psFilter,

layerObj *psLayer) {

char *pszExpression = NULL;

CPLXMLNode *psTmpNextNode = NULL;

CPLXMLNode *psTmpNode = NULL;

FilterEncodingNode *psNode = NULL;

char *pszTmpFilter = NULL;

layerObj *psCurrentLayer = NULL;

const char *pszWmsName = NULL;

const char *key = NULL;

/* clone the tree and set the next node to null */

/* so we only have the Filter node */

psTmpNode = CPLCloneXMLTree(psFilter);

psTmpNextNode = psTmpNode->psNext;

psTmpNode->psNext = NULL;

pszTmpFilter = CPLSerializeXMLTree(psTmpNode);

psTmpNode->psNext = psTmpNextNode;

CPLDestroyXMLNode(psTmpNode);

if (pszTmpFilter) {

psNode = FLTParseFilterEncoding(pszTmpFilter);

CPLFree(pszTmpFilter);

}

if (psNode) {

int j;

/*preparse the filter for possible gml aliases set on the layer's metadata:

"gml_NA3DESC_alias" "alias_name" and filter could be

<ogc:PropertyName>alias_name</ogc:PropertyName> #3079*/

for (j = 0; j < psLayer->map->numlayers; j++) {

psCurrentLayer = GET_LAYER(psLayer->map, j);

pszWmsName =

msOWSLookupMetadata(&(psCurrentLayer->metadata), "MO", "name");

if ((psCurrentLayer->name && psLayer->name &&

strcasecmp(psCurrentLayer->name, psLayer->name) == 0) ||

(psCurrentLayer->group && psLayer->name &&

strcasecmp(psCurrentLayer->group, psLayer->name) == 0) ||

(psLayer->name && pszWmsName &&

strcasecmp(pszWmsName, psLayer->name) == 0))

break;

}

if (j < psLayer->map->numlayers) {

/*make sure that the tmp layer has all the metadata that

the original layer has, allowing to do parsing for

such things as gml_attribute_type #3052*/

while (1) {

key = msNextKeyFromHashTable(&psCurrentLayer->metadata, key);

if (!key)

break;

else

msInsertHashTable(&psLayer->metadata, key,

msLookupHashTable(&psCurrentLayer->metadata, key));

}

FLTPreParseFilterForAliasAndGroup(psNode, psLayer->map, j, "G");

}

pszExpression = FLTGetCommonExpression(psNode, psLayer);

FLTFreeFilterEncodingNode(psNode);

}

return pszExpression;

}

/************************************************************************/

/* msSLDParseUserStyle */

/* */

/* Parse UserStyle node. */

/************************************************************************/

static void msSLDParseUserStyle(CPLXMLNode *psUserStyle, layerObj *psLayer) {

CPLXMLNode *psFeatureTypeStyle;

const char *pszUserStyleName = CPLGetXMLValue(psUserStyle, "Name", NULL);

if (pszUserStyleName) {

const char *pszIsDefault = CPLGetXMLValue(psUserStyle, "IsDefault", "0");

if (EQUAL(pszIsDefault, "true") || EQUAL(pszIsDefault, "1")) {

msFree(psLayer->classgroup);

psLayer->classgroup = msStrdup(pszUserStyleName);

}

}

LOOP_ON_CHILD_ELEMENT(psUserStyle, psFeatureTypeStyle, "FeatureTypeStyle") {

CPLXMLNode *psRule;

/* -------------------------------------------------------------------- */

/* Parse rules with no Else filter. */

/* -------------------------------------------------------------------- */

LOOP_ON_CHILD_ELEMENT(psFeatureTypeStyle, psRule, "Rule") {

CPLXMLNode *psFilter = NULL;

CPLXMLNode *psElseFilter = NULL;

int nNewClasses = 0, nClassBeforeFilter = 0, nClassAfterFilter = 0;

int nClassAfterRule = 0, nClassBeforeRule = 0;

/* used for scale setting */

nClassBeforeRule = psLayer->numclasses;

psElseFilter = CPLGetXMLNode(psRule, "ElseFilter");

nClassBeforeFilter = psLayer->numclasses;

if (psElseFilter == NULL)

msSLDParseRule(psRule, psLayer, pszUserStyleName);

nClassAfterFilter = psLayer->numclasses;

/* -------------------------------------------------------------------- */

/* Parse the filter and apply it to the latest class created by */

/* the rule. */

/* NOTE : Spatial Filter is not supported. */

/* -------------------------------------------------------------------- */

psFilter = CPLGetXMLNode(psRule, "Filter");

if (psFilter && psFilter->psChild && psFilter->psChild->pszValue) {

char *pszExpression =

msSLDGetCommonExpressionFromFilter(psFilter, psLayer);

if (pszExpression) {

int i;

nNewClasses = nClassAfterFilter - nClassBeforeFilter;

for (i = 0; i < nNewClasses; i++) {

expressionObj *exp =

&(psLayer->_class[psLayer->numclasses - 1 - i]->expression);

msFreeExpression(exp);

msInitExpression(exp);

exp->string = msStrdup(pszExpression);

exp->type = MS_EXPRESSION;

}

msFree(pszExpression);

pszExpression = NULL;

}

}

nClassAfterRule = psLayer->numclasses;

nNewClasses = nClassAfterRule - nClassBeforeRule;

/* apply scale and title to newly created classes */

_SLDApplyRuleValues(psRule, psLayer, nNewClasses);

/* TODO : parse legendgraphic */

}

/* -------------------------------------------------------------------- */

/* First parse rules with the else filter. These rules will */

/* create the classes that are placed at the end of class */

/* list. (See how classes are applied to layers in function */

/* msSLDApplySLD). */

/* -------------------------------------------------------------------- */

LOOP_ON_CHILD_ELEMENT(psFeatureTypeStyle, psRule, "Rule") {

CPLXMLNode *psElseFilter = CPLGetXMLNode(psRule, "ElseFilter");

if (psElseFilter) {

const int nNumClassesBeforeRule = psLayer->numclasses;

msSLDParseRule(psRule, psLayer, pszUserStyleName);

const int nNumClassesAfterRule = psLayer->numclasses;

const int nNumClassesAdded =

nNumClassesAfterRule - nNumClassesBeforeRule;

if (nNumClassesAdded > 0) {

_SLDApplyRuleValues(psRule, psLayer, nNumClassesAdded);

for (int i = 0; i < nNumClassesAdded; ++i) {

psLayer->_class[psLayer->numclasses - 1 - i]->isfallback = TRUE;

}

}

}

}

}

}

/************************************************************************/

/* msSLDParseNamedLayer */

/* */

/* Parse NamedLayer root. */

/************************************************************************/

int msSLDParseNamedLayer(CPLXMLNode *psRoot, layerObj *psLayer) {

CPLXMLNode *psLayerFeatureConstraints = NULL;

if (!psRoot || !psLayer)

return MS_FAILURE;

if (CPLGetXMLNode(psRoot, "UserStyle")) {

CPLXMLNode *psUserStyle;

LOOP_ON_CHILD_ELEMENT(psRoot, psUserStyle, "UserStyle") {

msSLDParseUserStyle(psUserStyle, psLayer);

}

}

/* check for Named styles*/

else {

CPLXMLNode *psNamedStyle = CPLGetXMLNode(psRoot, "NamedStyle");

if (psNamedStyle) {

CPLXMLNode *psSLDName = CPLGetXMLNode(psNamedStyle, "Name");

if (psSLDName && psSLDName->psChild && psSLDName->psChild->pszValue) {

msFree(psLayer->classgroup);

psLayer->classgroup = msStrdup(psSLDName->psChild->pszValue);

}

}

}

/* Deal with LayerFeatureConstraints */

psLayerFeatureConstraints = CPLGetXMLNode(psRoot, "LayerFeatureConstraints");

if (psLayerFeatureConstraints != NULL) {

CPLXMLNode *psIter = psLayerFeatureConstraints->psChild;

CPLXMLNode *psFeatureTypeConstraint = NULL;

for (; psIter != NULL; psIter = psIter->psNext) {

if (psIter->eType == CXT_Element &&

strcmp(psIter->pszValue, "FeatureTypeConstraint") == 0) {

if (psFeatureTypeConstraint == NULL) {

psFeatureTypeConstraint = psIter;

} else {

msSetError(MS_WMSERR,

"Only one single FeatureTypeConstraint element "

"per LayerFeatureConstraints is supported",

"");

return MS_FAILURE;

}

}

}

if (psFeatureTypeConstraint != NULL) {

CPLXMLNode *psFilter;

if (CPLGetXMLNode(psFeatureTypeConstraint, "FeatureTypeName") != NULL) {

msSetError(MS_WMSERR,