← Back to branch summary

~ubuntu-branches/ubuntu/saucy/mapserver/saucy-security

« back to all changes in this revision

Viewing changes to mapogcsos.c

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2011-12-23 14:02:06 UTC
  • mfrom: (26.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20111223140206-n3h9t2hsa8hyslmu
Tags: 6.0.1-2
Added missed stuff for libmapscript-perl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapogcsos.c
1
1
/**********************************************************************
2
 
 * $Id: mapogcsos.c 9498 2009-10-20 13:38:46Z aboudreault $
 
2
 * $Id: mapogcsos.c 11890 2011-07-12 13:06:14Z assefa $
3
3
 *
4
4
 * Project:  MapServer
5
5
 * Purpose:  OGC SOS implementation
27
27
 * DEALINGS IN THE SOFTWARE.
28
28
 **********************************************************************/
29
29
 
 
30
#define _GNU_SOURCE
 
31
 
30
32
#include "mapserver.h"
31
33
 
32
34
 
33
 
MS_CVSID("$Id: mapogcsos.c 9498 2009-10-20 13:38:46Z aboudreault $")
 
35
MS_CVSID("$Id: mapogcsos.c 11890 2011-07-12 13:06:14Z assefa $")
34
36
 
35
37
#if defined(USE_SOS_SVR) && defined(USE_LIBXML2)
36
38
 
117
119
  xmlFree(buffer);
118
120
  xmlFreeDoc(psDoc);
119
121
 
120
 
  /* clear error since we have already reported it */
121
 
  msResetErrorList();
 
122
  /* 
 
123
  ** The typical pattern is to call msSOSException() right after 
 
124
  ** msSetError().  In order to prevent mapserv.c from re-reporting this
 
125
  ** error at a higher level, we mark it as reported here. #3571
 
126
  */
 
127
  {
 
128
      errorObj *err = msGetErrorObj();
 
129
      if( err != NULL && err->code != MS_NOERR )
 
130
          err->isreported = MS_TRUE;
 
131
  }
122
132
 
123
133
  return MS_FAILURE;
124
134
}
280
290
        psCompNode = xmlNewChild(psNode, psNsSwe, BAD_CAST "CompositePhenomenon", NULL);
281
291
        pszValue = msOWSLookupMetadata(&(lp->metadata), "S", 
282
292
                                       "observedproperty_id");
283
 
        pszTmpVal = strdup(pszValue);
 
293
        pszTmpVal = msStrdup(pszValue);
284
294
 
285
295
        if (pszCompositePhenomenonId != NULL) { /* unique value needs to be constructed */
286
296
            pszTmpVal = msStringConcatenate(pszTmpVal, "_");
306
316
            pszValue = msOWSLookupMetadata(&(lp->metadata), "S", "observedproperty_authority");
307
317
 
308
318
            if (pszValue)
309
 
              pszTmpVal = strdup(pszValue);
 
319
              pszTmpVal = msStrdup(pszValue);
310
320
            else
311
 
              pszTmpVal = strdup("OGC-SWE");
 
321
              pszTmpVal = msStrdup("OGC-SWE");
312
322
 
313
 
            pszFullName = strdup(pszComponentBase);
 
323
            pszFullName = msStrdup(pszComponentBase);
314
324
 
315
325
            pszFullName = msStringConcatenate(pszFullName, pszTmpVal);
316
326
 
321
331
            pszValue = msOWSLookupMetadata(&(lp->metadata), "S", "observedproperty_version");
322
332
 
323
333
            if (pszValue)
324
 
              pszTmpVal = strdup(pszValue);
 
334
              pszTmpVal = msStrdup(pszValue);
325
335
            else 
326
 
              pszTmpVal = strdup("1");
 
336
              pszTmpVal = msStrdup("1");
327
337
 
328
338
            pszFullName = msStringConcatenate(pszFullName, pszTmpVal);
329
339
 
331
341
 
332
342
            pszFullName = msStringConcatenate(pszFullName, ":");
333
343
 
334
 
            sprintf(szTmp, "%s_alias", lp->items[i]);
 
344
            snprintf(szTmp, sizeof(szTmp), "%s_alias", lp->items[i]);
335
345
            pszValue = msOWSLookupMetadata(&(lp->metadata), "S", szTmp);
336
346
 
337
347
            if (pszValue)
338
 
              pszTmpVal = strdup(pszValue);
 
348
              pszTmpVal = msStrdup(pszValue);
339
349
            else
340
 
              pszTmpVal = strdup(lp->items[i]);
 
350
              pszTmpVal = msStrdup(lp->items[i]);
341
351
 
342
352
            pszFullName = msStringConcatenate(pszFullName, pszTmpVal);
343
353
 
395
405
              /*add all points */
396
406
              for(i=0; i<psShape->line[0].numpoints; i++)
397
407
              {
398
 
                  psNode = xmlAddChild(psPointNode, msGML3Point(psNsGml, pszEpsg, NULL, psShape->line[0].point[0].x, psShape->line[0].point[0].y));
 
408
                  psNode = xmlAddChild(psPointNode, msGML3Point(psNsGml, pszEpsg, NULL, psShape->line[0].point[i].x, psShape->line[0].point[i].y));
399
409
              }
400
410
              break;
401
411
              
581
591
        /*assuming that the layer is open */       
582
592
        for(i=0; i<lp->numitems; i++) 
583
593
        {
584
 
            sprintf(szTmp, "%s_alias", lp->items[i]);
 
594
            snprintf(szTmp, sizeof(szTmp), "%s_alias", lp->items[i]);
585
595
            pszValue = msOWSLookupMetadata(&(lp->metadata), "S", szTmp);
586
596
            if (pszValue)
587
597
            {
588
598
                psNode = xmlNewChild(psRecordNode, NULL, BAD_CAST "field", NULL);
589
599
 
590
600
                /* check if there is an alias/full name used */
591
 
                sprintf(szTmp, "%s_alias", lp->items[i]);
 
601
                snprintf(szTmp, sizeof(szTmp), "%s_alias", lp->items[i]);
592
602
                pszName = msOWSLookupMetadata(&(lp->metadata), "S", szTmp);
593
603
                if (!pszName)
594
604
                  pszName = lp->items[i];
598
608
                psNode = xmlNewChild(psNode, NULL, BAD_CAST "Quantity", NULL);
599
609
 
600
610
                /* get definition and uom */
601
 
                sprintf(szTmp, "%s_definition", lp->items[i]);
 
611
                snprintf(szTmp, sizeof(szTmp), "%s_definition", lp->items[i]);
602
612
                pszDefinition =  msOWSLookupMetadata(&(lp->metadata), "S", szTmp);
603
613
                    
604
614
                if (pszDefinition == NULL)
606
616
 
607
617
                xmlNewNsProp(psNode, NULL, BAD_CAST "definition", BAD_CAST pszDefinition);
608
618
 
609
 
                sprintf(szTmp, "%s_uom", lp->items[i]);
 
619
                snprintf(szTmp, sizeof(szTmp), "%s_uom", lp->items[i]);
610
620
                pszUom =  msOWSLookupMetadata(&(lp->metadata), "S", szTmp);
611
621
 
612
622
                if (pszUom == NULL)
676
686
    {
677
687
        msInitShape(&sShape);
678
688
    
679
 
        status = msLayerResultsGetShape(lp, &sShape, 
680
 
                                 lp->resultcache->results[iFeatureId].tileindex, 
681
 
                                 lp->resultcache->results[iFeatureId].shapeindex);
 
689
        status = msLayerGetShape(lp, &sShape, &(lp->resultcache->results[iFeatureId]));
682
690
        if(status != MS_SUCCESS) {
683
691
          xmlFreeNs(psNsOm);
684
692
          return;
753
761
                }
754
762
                if (i < lpfirst->numitems)
755
763
                {
756
 
                    sprintf(szTmp, "%s", "urn:ogc:def:procedure:");
 
764
                    snprintf(szTmp, sizeof(szTmp), "%s", "urn:ogc:def:procedure:");
757
765
                    pszTmp = msStringConcatenate(pszTmp, szTmp);
758
766
                    pszValueShape = msEncodeHTMLEntities(sShape.values[i]);
759
767
                    pszTmp = msStringConcatenate(pszTmp, pszValueShape);
775
783
            if (! msOWSLookupMetadata(&(lp->metadata), "S", "procedure_item"))
776
784
                xmlAddSibling(psNode, xmlNewComment(BAD_CAST "WARNING: Optional metadata \"sos_procedure_item\" missing for sos:procedure.  If you have more than 1 procedures, sos:procedure will output them incorrectly."));
777
785
 
778
 
            sprintf(szTmp, "%s", "urn:ogc:def:procedure:");
 
786
            snprintf(szTmp, sizeof(szTmp), "%s", "urn:ogc:def:procedure:");
779
787
            pszTmp = msStringConcatenate(pszTmp, szTmp);
780
788
            pszTmp = msStringConcatenate(pszTmp, (char *)pszValue);
781
789
            
790
798
                                       "observedproperty_id");
791
799
        if (pszValue)
792
800
            msSOSAddPropertyNode(psNsSwe, psNsXLink, psObsNode, lp, psNsGml, pszOid);
 
801
        msFree(pszOid);
 
802
        pszOid = NULL;
793
803
 
794
804
        /*TODO add featureofinterest*/
795
805
 
800
810
        psNode =  xmlNewChild(psObsNode, psNsOm, BAD_CAST "featureOfInterest", NULL);
801
811
        xmlNewNsProp(psNode, psNsXLink, BAD_CAST "href", BAD_CAST pszTmp);
802
812
 
 
813
        msFree(pszTmp);
803
814
        pszTmp=NULL;
804
815
 
805
816
        /* add result : gml:featureMember of all selected elements */
856
867
        {
857
868
            for(i=0; i<lpfirst->numitems; i++) 
858
869
            {
859
 
                sprintf(szTmp, "%s_alias", lpfirst->items[i]);
 
870
                snprintf(szTmp, sizeof(szTmp), "%s_alias", lpfirst->items[i]);
860
871
                pszValue = msOWSLookupMetadata(&(lpfirst->metadata), "S", szTmp);
861
872
                if (pszValue)
862
873
                {
866
877
                        {
867
878
                            /*if there is an alias used, use it to output the
868
879
                              parameter name : eg "sos_AMMON_DIS_alias" "Amonia"  */
869
 
                            sprintf(szTmp, "%s_alias", lpfirst->items[i]);
 
880
                            snprintf(szTmp, sizeof(szTmp), "%s_alias", lpfirst->items[i]);
870
881
                            pszValue = msOWSLookupMetadata(&(lpfirst->metadata), "S", szTmp);
871
882
                            pszValueShape = msEncodeHTMLEntities(sShape.values[j]);
872
883
                            
897
908
              msLayerClose(lpfirst);
898
909
        }
899
910
    }
 
911
 
 
912
    msFreeShape(&sShape);
900
913
}
901
914
 
902
915
/************************************************************************/
918
931
    const char *pszSep=NULL;
919
932
 
920
933
    msInitShape(&sShape);
921
 
    status = msLayerResultsGetShape(lp, &sShape, 
922
 
                             lp->resultcache->results[iFeatureId].tileindex, 
923
 
                             lp->resultcache->results[iFeatureId].shapeindex);
 
934
    status = msLayerGetShape(lp, &sShape, &(lp->resultcache->results[iFeatureId]));
924
935
    if(status != MS_SUCCESS) 
925
936
      return NULL;
926
937
 
943
954
        {
944
955
            if (strcasecmp(lp->items[i], pszProcedureField) == 0)
945
956
            {
946
 
                (*ppszProcedure) = strdup( sShape.values[i]);
 
957
                (*ppszProcedure) = msStrdup( sShape.values[i]);
947
958
                break;
948
959
            }
949
960
        }
964
975
                                     "encoding_tokenSeparator");
965
976
        for(i=0; i<lpfirst->numitems; i++) 
966
977
        {
967
 
            sprintf(szTmp, "%s_alias", lpfirst->items[i]);
 
978
            snprintf(szTmp, sizeof(szTmp), "%s_alias", lpfirst->items[i]);
968
979
            pszValue = msOWSLookupMetadata(&(lpfirst->metadata), "S", szTmp);
969
980
            if (pszValue)
970
981
            {
1123
1134
                    if (psTime && psTime->pszValue && psTime->eType == CXT_Text)
1124
1135
                    {
1125
1136
                        if (msParseTime(psTime->pszValue, &tm_struct) == MS_TRUE)
1126
 
                          pszReturn = strdup(psTime->pszValue);
 
1137
                          pszReturn = msStrdup(psTime->pszValue);
1127
1138
                    }
1128
1139
                }
1129
1140
            }
1138
1149
                {
1139
1150
                    if (psBegin->psChild && psBegin->psChild->pszValue &&
1140
1151
                        psBegin->psChild->eType == CXT_Text)
1141
 
                      pszBegin = strdup( psBegin->psChild->pszValue);
 
1152
                      pszBegin = msStrdup( psBegin->psChild->pszValue);
1142
1153
 
1143
1154
                    if (psEnd->psChild && psEnd->psChild->pszValue &&
1144
1155
                        psEnd->psChild->eType == CXT_Text)
1145
 
                      pszEnd = strdup(psEnd->psChild->pszValue);
 
1156
                      pszEnd = msStrdup(psEnd->psChild->pszValue);
1146
1157
 
1147
1158
                    if (pszBegin && pszEnd)
1148
1159
                    {
1149
1160
                        if (msParseTime(pszBegin, &tm_struct) == MS_TRUE &&
1150
1161
                            msParseTime(pszEnd, &tm_struct) == MS_TRUE)
1151
1162
                        {
1152
 
                            pszReturn = strdup(pszBegin);
 
1163
                            pszReturn = msStrdup(pszBegin);
1153
1164
                            pszReturn = msStringConcatenate(pszReturn, "/");
1154
1165
                            pszReturn = msStringConcatenate(pszReturn, pszEnd);
1155
1166
                        }
1156
1167
                    }
 
1168
                    msFree(pszBegin);
 
1169
                    msFree(pszEnd);
1157
1170
                }
1158
1171
            }
1159
1172
        }
1160
1173
    }
1161
 
    free(psRoot);
 
1174
    CPLDestroyXMLNode(psRoot);
1162
1175
    return pszReturn;
1163
1176
}
1164
1177
 
1168
1181
/*                                                                      */
1169
1182
/*      getCapabilities request handler.                                */
1170
1183
/************************************************************************/
1171
 
int msSOSGetCapabilities(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req) {
 
1184
int msSOSGetCapabilities(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req, owsRequestObj *ows_request) {
1172
1185
    xmlDocPtr psDoc = NULL;       /* document pointer */
1173
1186
    xmlNodePtr psRootNode, psMainNode, psNode;
1174
1187
    xmlNodePtr psOfferingNode;
1176
1189
 
1177
1190
    char *schemalocation = NULL;
1178
1191
    char *xsi_schemaLocation = NULL;
1179
 
    const char *script_url=NULL;
 
1192
    char *script_url=NULL;
1180
1193
    const char *updatesequence=NULL;
1181
1194
    const char *encoding;
1182
1195
 
1305
1318
 
1306
1319
    /*schema fixed*/
1307
1320
    schemalocation = msEncodeHTMLEntities( msOWSGetSchemasLocation(map) );
1308
 
    xsi_schemaLocation = strdup(pszSOSNamespaceUri);
 
1321
    xsi_schemaLocation = msStrdup(pszSOSNamespaceUri);
1309
1322
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, " ");
1310
1323
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, schemalocation);
1311
1324
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, "/sos/");
1332
1345
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
1333
1346
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
1334
1347
 
1335
 
    psNode     = xmlAddChild(psMainNode, msOWSCommonOperationsMetadataOperation(psNsOws,psNsXLink,"DescribeSensor", OWS_METHOD_GETPOST, (char *) script_url));
1336
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
1337
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
1338
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "sensorid", "urn:ogc:object:procedure"));
1339
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "outputFormat", (char *)pszSOSDescribeSensorMimeType));
1340
 
 
1341
 
    psNode     = xmlAddChild(psMainNode, msOWSCommonOperationsMetadataOperation(psNsOws,psNsXLink,"GetObservation", OWS_METHOD_GETPOST, (char *) script_url));
1342
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
1343
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
1344
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "offering", "urn:ogc:object:offering"));
1345
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "observedproperty", "urn:ogc:object:observedproperty"));
1346
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "eventtime", "sos:time"));
1347
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "procedure", "urn:ogc:object:sensor"));
1348
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "featureofinterest", "gml:location"));
1349
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "result", "ogc:Filter"));
1350
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "responseFormat", (char *)pszSOSGetObservationMimeType));
1351
 
    psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "resultModel", "Observation,Measurement"));
 
1348
    if (msOWSRequestIsEnabled(map, NULL, "S", "DescribeSensor", MS_TRUE)) 
 
1349
    {
 
1350
        psNode     = xmlAddChild(psMainNode, msOWSCommonOperationsMetadataOperation(psNsOws,psNsXLink,"DescribeSensor", OWS_METHOD_GETPOST, (char *) script_url));
 
1351
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
 
1352
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
 
1353
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "sensorid", "urn:ogc:object:procedure"));
 
1354
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "outputFormat", (char *)pszSOSDescribeSensorMimeType));
 
1355
    }
 
1356
 
 
1357
    if (msOWSRequestIsEnabled(map, NULL, "S", "DescribeObservationType", MS_TRUE))
 
1358
    {
 
1359
        psNode     = xmlAddChild(psMainNode, msOWSCommonOperationsMetadataOperation(psNsOws,psNsXLink,"DescribeObservationType", OWS_METHOD_GETPOST, (char *) script_url));
 
1360
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
 
1361
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
 
1362
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "observedproperty", "urn:ogc:object:observedproperty"));
 
1363
    }
 
1364
 
 
1365
    if (msOWSRequestIsEnabled(map, NULL, "S", "GetObservation", MS_TRUE)) 
 
1366
    {
 
1367
        psNode     = xmlAddChild(psMainNode, msOWSCommonOperationsMetadataOperation(psNsOws,psNsXLink,"GetObservation", OWS_METHOD_GETPOST, (char *) script_url));
 
1368
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "service", "SOS"));
 
1369
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "version", (char *)pszSOSVersion));
 
1370
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "offering", "urn:ogc:object:offering"));
 
1371
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "observedproperty", "urn:ogc:object:observedproperty"));
 
1372
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "eventtime", "sos:time"));
 
1373
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "procedure", "urn:ogc:object:sensor"));
 
1374
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "featureofinterest", "gml:location"));
 
1375
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "result", "ogc:Filter"));
 
1376
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "responseFormat", (char *)pszSOSGetObservationMimeType));
 
1377
        psTmpNode  = xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(ows_version, psNsOws,"Parameter", "resultModel", "Observation,Measurement"));
 
1378
    }
1352
1379
 
1353
1380
    value = msOWSLookupMetadata(&(map->web.metadata), "SO", "maxfeatures");
1354
1381
 
1362
1389
    /*Offerings */
1363
1390
     psNode = xmlNewChild(psRootNode, NULL, BAD_CAST "Contents", NULL);
1364
1391
     psMainNode = xmlNewChild(psNode, NULL, BAD_CAST "ObservationOfferingList", NULL);
1365
 
                                             
1366
1392
     
1367
1393
     /*go through the layers and check for metadata sos_offering_id.
1368
1394
       One or more layers could have the same offering id. In that case they
1383
1409
                continue;
1384
1410
 
1385
1411
             value = msOWSLookupMetadata(&(lp->metadata), "S", "offering_id");
1386
 
             if (value)
 
1412
             if (value && (msIntegerInArray(lp->index, ows_request->enabled_layers, ows_request->numlayers)))
1387
1413
             {
1388
1414
                 nCurrentOff = -1;
1389
1415
                 for (j=0; j<nOfferings; j++)
1398
1424
                   panOfferingLayers[i] = nCurrentOff;
1399
1425
                 else /*new offering */
1400
1426
                 {
1401
 
                     papsOfferings[nOfferings] = strdup(value);
 
1427
                     papsOfferings[nOfferings] = msStrdup(value);
1402
1428
                     panOfferingLayers[i] = nOfferings;
1403
1429
                     nOfferings++;
1404
1430
                 }
1405
1431
             }
1406
1432
         }
1407
 
 
 
1433
         
1408
1434
         if (nOfferings > 0)
1409
1435
         {
1410
1436
             for (i=0; i<nOfferings; i++)
1513
1539
                             for (k=0; k<n; k++)
1514
1540
                             {
1515
1541
                                 /*TODO review the urn output */
1516
 
                                 sprintf(szTmp, "%s", "urn:ogc:def:procedure:");
 
1542
                                 snprintf(szTmp, sizeof(szTmp), "%s", "urn:ogc:def:procedure:");
1517
1543
                                 pszTmp = msStringConcatenate(pszTmp, szTmp);
1518
1544
                                 pszTmp = msStringConcatenate(pszTmp, tokens[k]);
1519
1545
 
1536
1562
 
1537
1563
                             lpTmp = GET_LAYER(map,j);
1538
1564
                             if (lpTmp->template == NULL)
1539
 
                               lpTmp->template = strdup("ttt");
 
1565
                               lpTmp->template = msStrdup("ttt");
1540
1566
 
1541
1567
                             map->query.type = MS_QUERY_BY_RECT;
1542
1568
                             map->query.mode = MS_QUERY_MULTIPLE;
1579
1605
                                 for(k=0; k<lpTmp->resultcache->numresults; k++)
1580
1606
                                 {      
1581
1607
                                     msInitShape(&sShape);
1582
 
                                     status = msLayerResultsGetShape(lp, &sShape, 
1583
 
                                                              lpTmp->resultcache->results[k].tileindex, 
1584
 
                                                              lpTmp->resultcache->results[k].shapeindex);
 
1608
                                     status = msLayerGetShape(lp, &sShape, &(lpTmp->resultcache->results[k]));
1585
1609
                                     if(status != MS_SUCCESS) 
1586
1610
                                       continue;
1587
1611
 
1590
1614
                                         pszProcedure = msStringConcatenate(pszProcedure, sShape.values[iItemPosition]);
1591
1615
                                         if (!_IsInList(papsProcedures, nDistinctProcedures, pszProcedure))
1592
1616
                                         {
1593
 
                                               papsProcedures[nDistinctProcedures] = strdup(pszProcedure);
 
1617
                                               papsProcedures[nDistinctProcedures] = msStrdup(pszProcedure);
1594
1618
                                               nDistinctProcedures++;
1595
 
                                               sprintf(szTmp, "%s", "urn:ogc:def:procedure:");
 
1619
                                               snprintf(szTmp, sizeof(szTmp), "%s", "urn:ogc:def:procedure:");
1596
1620
                                               pszTmp = msStringConcatenate(pszTmp, szTmp);
1597
1621
                                               pszTmp = msStringConcatenate(pszTmp, pszProcedure);
1598
1622
 
1655
1679
                             }
1656
1680
                             if (k == nProperties)/*not found*/
1657
1681
                             {
1658
 
                                 papszProperties[nProperties] = strdup(value);
 
1682
                                 papszProperties[nProperties] = msStrdup(value);
1659
1683
                                 nProperties++;
1660
1684
                                 lpTmp = GET_LAYER(map, j);
1661
1685
                                 if (msLayerOpen(lpTmp) == MS_SUCCESS && msLayerGetItems(lpTmp) == MS_SUCCESS)
1691
1715
         {
1692
1716
             for (i=0; i<nOfferings; i++)
1693
1717
               msFree(papsOfferings[i]);
1694
 
             msFree(papsOfferings);
1695
1718
         }
 
1719
         msFree(papsOfferings);
1696
1720
         if(panOfferingLayers)
1697
1721
           msFree(panOfferingLayers);        
1698
1722
 
1733
1757
 
1734
1758
     free(xsi_schemaLocation);
1735
1759
     free(schemalocation);
 
1760
     msFree(script_url);
1736
1761
 
1737
1762
    /*
1738
1763
     *Free the global variables that may
1778
1803
/*                                                                      */
1779
1804
/*      GetObservation request handler                                  */
1780
1805
/************************************************************************/
1781
 
int msSOSGetObservation(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req) {
 
1806
int msSOSGetObservation(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req, owsRequestObj *ows_request) {
1782
1807
  char *schemalocation = NULL;
1783
1808
  char *xsi_schemaLocation = NULL;
1784
1809
  const char *pszTmp = NULL, *pszTmp2 = NULL;
1785
1810
  const char *user_namespace_uri = "http://mapserver.gis.umn.edu/mapserver";
1786
1811
  const char *user_namespace_prefix = "ms";
1787
 
  const char *script_url=NULL;
 
1812
  char *script_url=NULL;
1788
1813
  int i, j, k, bLayerFound = 0;
1789
1814
  layerObj *lp = NULL, *lpfirst = NULL; 
1790
1815
  const char *pszTimeExtent=NULL, *pszTimeField=NULL, *pszValue=NULL;
1800
1825
  xmlNsPtr psNsSwe = NULL;
1801
1826
  xmlNsPtr psNsXLink = NULL;
1802
1827
  xmlNsPtr psNsSos = NULL;
1803
 
  xmlNsPtr psNsOws = NULL;
1804
 
  xmlNsPtr psNsXsi = NULL;
1805
1828
  xmlNsPtr psNsMs = NULL;
1806
1829
  const char *opLayerName = NULL;
1807
1830
  char *pszBuffer = NULL;
1861
1884
 
1862
1885
  /*validate if offering exists*/
1863
1886
  for (i=0; i<map->numlayers; i++) {
1864
 
    pszTmp = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "S", "offering_id");
1865
 
    if (pszTmp && (strcasecmp(pszTmp, sosparams->pszOffering) == 0))
 
1887
      pszTmp = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "S", "offering_id");
 
1888
    if (pszTmp && (strcasecmp(pszTmp, sosparams->pszOffering) == 0) && 
 
1889
        (msIntegerInArray(GET_LAYER(map, i)->index, ows_request->enabled_layers, ows_request->numlayers)))
1866
1890
      break;
1867
1891
  }
1868
1892
 
1891
1915
          for (j=0; j<n; j++) {
1892
1916
            if(strcasecmp(pszTmp2, tokens[j]) == 0) {
1893
1917
              GET_LAYER(map, i)->status = MS_ON;
1894
 
              //opLayerName = strdup(GET_LAYER(map, i)->name);
 
1918
              //opLayerName = msStrdup(GET_LAYER(map, i)->name);
1895
1919
              opLayerName = GET_LAYER(map, i)->name;
1896
1920
              /* Force setting a template to enable query. */
1897
1921
              if (!GET_LAYER(map, i)->template)
1898
 
                GET_LAYER(map, i)->template = strdup("ttt.html");
 
1922
                GET_LAYER(map, i)->template = msStrdup("ttt.html");
1899
1923
              bLayerFound = 1;
1900
1924
              break;
1901
1925
            }
1968
1992
              /* need to query the layer and get the values from each feature */
1969
1993
 
1970
1994
              if (lp->template == NULL)
1971
 
                lp->template = strdup("ttt");
 
1995
                lp->template = msStrdup("ttt");
1972
1996
 
1973
1997
              map->query.type = MS_QUERY_BY_RECT;
1974
1998
              map->query.mode = MS_QUERY_MULTIPLE;
1997
2021
 
1998
2022
                for(k=0; k<lp->resultcache->numresults; k++) {      
1999
2023
                  msInitShape(&sShape);
2000
 
                  status = msLayerResultsGetShape(lp, &sShape, lp->resultcache->results[k].tileindex, lp->resultcache->results[k].shapeindex);
 
2024
                  status = msLayerGetShape(lp, &sShape, &(lp->resultcache->results[k]));
2001
2025
                  if(status != MS_SUCCESS) 
2002
2026
                    continue;
2003
2027
 
2117
2141
    /* this is passed directly to mapogcfilter.                                          */
2118
2142
    /* for GET requests, we strip the parent element before passing                      */
2119
2143
 
2120
 
    pszTmp = strdup(sosparams->pszEventTime);
 
2144
    pszTmp = msStrdup(sosparams->pszEventTime);
2121
2145
 
2122
2146
    pszTmp = msCaseReplaceSubstring(pszTmp, "<ogc:TM_Equals>", "");
2123
2147
    pszTmp = msCaseReplaceSubstring(pszTmp, "<TM_Equals>", "");
2197
2221
 
2198
2222
    /* TODO we should reproject the bbox to the map projection if there is an srs defined */
2199
2223
    if (!bValid) {
2200
 
            msSetError(MS_SOSERR, "Invalid gml:Envelope value given for featureOfInterest %s.", "msSOSGetObservation()", sosparams->pszEventTime);
2201
 
            return msSOSException(map, "featureofinterest", "InvalidParameterValue");
2202
 
        }
2203
 
        map->extent.minx = sBbox.minx;
2204
 
        map->extent.miny = sBbox.miny;
2205
 
        map->extent.maxx = sBbox.maxx;
2206
 
        map->extent.maxy = sBbox.maxy;
 
2224
        msSetError(MS_SOSERR, "Invalid gml:Envelope value given for featureOfInterest %s.", "msSOSGetObservation()", sosparams->pszEventTime);
 
2225
        return msSOSException(map, "featureofinterest", "InvalidParameterValue");
 
2226
    }
 
2227
    map->extent.minx = sBbox.minx;
 
2228
    map->extent.miny = sBbox.miny;
 
2229
    map->extent.maxx = sBbox.maxx;
 
2230
    map->extent.maxy = sBbox.maxy;
 
2231
 
 
2232
    CPLDestroyXMLNode(psRoot);
 
2233
    msFree(pszSRS);
2207
2234
  }
2208
2235
 
2209
2236
  if (sosparams->pszSrsName) { /* validate against MAP.WEB.METADATA.sos_srs */
2229
2256
            /* project MAP.EXTENT to this SRS */
2230
2257
            msInitProjection(&po);
2231
2258
 
2232
 
            sprintf(srsbuffer, "+init=epsg:%.20s", sosparams->pszSrsName+5);
 
2259
            snprintf(srsbuffer, sizeof(srsbuffer), "+init=epsg:%.20s", sosparams->pszSrsName+5);
2233
2260
 
2234
2261
            if (msLoadProjectionString(&po, srsbuffer) != 0) {
2235
2262
              msSetError(MS_SOSERR, "Could not set output projection to \"%s\"", "msSOSGetObservation()", sosparams->pszSrsName);
2291
2318
          }
2292
2319
          msLayerClose(lp);
2293
2320
        }
2294
 
        FLTApplyFilterToLayer(psFilterNode, map, i, MS_FALSE);
2295
 
        msFree(psFilterNode);
2296
 
        
 
2321
        FLTApplyFilterToLayer(psFilterNode, map, i);
2297
2322
      }
2298
2323
    }
 
2324
 
 
2325
    FLTFreeFilterEncodingNode(psFilterNode);
2299
2326
  }
2300
2327
 
2301
2328
  
2343
2370
    psNsSos = xmlNewNs(NULL, BAD_CAST "http://www.opengis.net/sos/1.0", BAD_CAST "sos");
2344
2371
    psNsGml = xmlNewNs(NULL, BAD_CAST "http://www.opengis.net/gml", BAD_CAST "gml");
2345
2372
    psNsOm = xmlNewNs(NULL, BAD_CAST pszOMNamespaceUri, BAD_CAST pszOMNamespacePrefix);
2346
 
    psNsOws = xmlNewNs(NULL, BAD_CAST "http://www.opengis.net/ows/1.1", BAD_CAST "ows");
2347
2373
    psNsSwe = xmlNewNs(NULL, BAD_CAST "http://www.opengis.net/swe/1.0.1", BAD_CAST "swe");
2348
2374
    psNsXLink = xmlNewNs(NULL, BAD_CAST MS_OWSCOMMON_W3C_XLINK_NAMESPACE_URI, BAD_CAST MS_OWSCOMMON_W3C_XLINK_NAMESPACE_PREFIX);
2349
 
    psNsXsi  = xmlNewNs(NULL, BAD_CAST MS_OWSCOMMON_W3C_XSI_NAMESPACE_URI, BAD_CAST MS_OWSCOMMON_W3C_XSI_NAMESPACE_PREFIX);
2350
2375
    psNsMs = xmlNewNs(NULL, BAD_CAST user_namespace_uri, BAD_CAST user_namespace_prefix);
2351
2376
 
2352
2377
    psDoc = xmlNewDoc(BAD_CAST "1.0");
2369
2394
    if ((script_url=msOWSGetOnlineResource(map, "SO", "onlineresource", req)) == NULL)
2370
2395
        return msSOSException(map, "NoApplicableCode", "NoApplicableCode");
2371
2396
 
2372
 
    xsi_schemaLocation = strdup("http://www.opengis.net/om/1.0 ");
 
2397
    xsi_schemaLocation = msStrdup("http://www.opengis.net/om/1.0 ");
2373
2398
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, schemalocation);
2374
2399
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, "/om/1.0.0/om.xsd ");
2375
2400
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, (char *) user_namespace_uri);
2550
2575
                                                                                       sizeof(SOSProcedureNode)
2551
2576
                                                                                       *nDiffrentProc);
2552
2577
 
2553
 
                                        paDiffrentProc[nDiffrentProc-1].pszProcedure = strdup(pszProcedureValue);
 
2578
                                        paDiffrentProc[nDiffrentProc-1].pszProcedure = msStrdup(pszProcedureValue);
2554
2579
                                        psObservationNode = msSOSAddMemberNodeObservation(psNsGml, psNsSos, psNsOm, psNsSwe, psNsXLink, psRootNode, map, 
2555
2580
                                                                                          (GET_LAYER(map, i)),
2556
2581
                                                                                          pszProcedureValue);
2581
2606
    else
2582
2607
        msIO_printf("Content-type: text/xml%c%c",10,10);
2583
2608
 
2584
 
     
2585
2609
     context = msIO_getHandler(stdout);
2586
2610
     xmlDocDumpFormatMemoryEnc(psDoc, &buffer, &size, (encoding ? encoding : "ISO-8859-1"), 1);
2587
2611
     msIO_contextWrite(context, buffer, size);
2594
2618
     xmlFreeNs(psNsXLink);
2595
2619
     xmlFreeNs(psNsMs);
2596
2620
     xmlFree(buffer);
 
2621
     msFree(script_url);
2597
2622
 
2598
2623
    /*free  document */
2599
2624
     xmlFreeDoc(psDoc);
2614
2639
/*                                                                      */
2615
2640
/*      Describe sensor request handler.                               */
2616
2641
/************************************************************************/
2617
 
int msSOSDescribeSensor(mapObj *map, sosParamsObj *sosparams) {
 
2642
int msSOSDescribeSensor(mapObj *map, sosParamsObj *sosparams, owsRequestObj *ows_request) {
2618
2643
  char *pszEncodedUrl = NULL;
2619
2644
  const char *pszId = NULL, *pszUrl = NULL;
2620
2645
  int i = 0, j=0, k=0;
2650
2675
      tokens = msStringSplit(pszId, ' ', &n);
2651
2676
      for (k=0; k<n; k++) {
2652
2677
        if (tokens[k] && strlen(tokens[k]) > 0) {
2653
 
          pszProcedureURI = strdup("urn:ogc:def:procedure:");
 
2678
          pszProcedureURI = msStrdup("urn:ogc:def:procedure:");
2654
2679
          pszProcedureURI = msStringConcatenate(pszProcedureURI, tokens[k]);
2655
 
          if (pszProcedureURI && strcasecmp(pszProcedureURI, sosparams->pszProcedure) == 0) {
 
2680
          if ( (pszProcedureURI && strcasecmp(pszProcedureURI, sosparams->pszProcedure) == 0) &&
 
2681
               (msIntegerInArray(lp->index, ows_request->enabled_layers, ows_request->numlayers)) ) {
2656
2682
            bFound = 1; 
2657
 
            pszProcedureId = strdup(tokens[k]);
 
2683
            pszProcedureId = msStrdup(tokens[k]);
2658
2684
            msFree(pszProcedureURI);
2659
2685
            msFreeCharArray(tokens, n);
2660
2686
            break;
2664
2690
      if (bFound) {
2665
2691
        pszUrl = msOWSLookupMetadata(&(lp->metadata), "S", "describesensor_url");
2666
2692
        if (pszUrl) {
2667
 
          pszTmp = strdup(pszUrl);
 
2693
          pszTmp = msStrdup(pszUrl);
2668
2694
 
2669
2695
          /* %procedure% is the hardcoded variable name to use 
2670
2696
             within sos_describesensor_url */
2671
2697
          tmpstr = (char *)malloc(sizeof(char)*strlen("procedure") + 3);
2672
2698
          sprintf(tmpstr,"%%%s%%", "procedure");
2673
 
          if (msCaseFindSubstring(pszUrl, tmpstr) != NULL)
 
2699
          if (strcasestr(pszUrl, tmpstr) != NULL)
2674
2700
            pszTmp = msCaseReplaceSubstring(pszTmp, tmpstr, pszProcedureId);
2675
2701
          msFree(tmpstr);
2676
2702
 
2700
2726
      }
2701
2727
      if (iItemPosition >=0) {
2702
2728
        if (lp->template == NULL)
2703
 
          lp->template = strdup("ttt");
 
2729
          lp->template = msStrdup("ttt");
2704
2730
 
2705
2731
        map->query.type = MS_QUERY_BY_RECT;
2706
2732
        map->query.mode = MS_QUERY_MULTIPLE;
2713
2739
        if (lp->resultcache && lp->resultcache->numresults > 0) {
2714
2740
          for(j=0; j<lp->resultcache->numresults; j++) {      
2715
2741
            msInitShape(&sShape);     
2716
 
            status = msLayerResultsGetShape(lp, &sShape, lp->resultcache->results[j].tileindex, lp->resultcache->results[j].shapeindex);
 
2742
            status = msLayerGetShape(lp, &sShape, &(lp->resultcache->results[j]));
2717
2743
            if(status != MS_SUCCESS) 
2718
2744
              continue;
2719
2745
 
2720
2746
            if (sShape.values[iItemPosition]) {
2721
 
              pszProcedureURI = strdup("urn:ogc:def:procedure:");
 
2747
              pszProcedureURI = msStrdup("urn:ogc:def:procedure:");
2722
2748
              pszProcedureURI = msStringConcatenate(pszProcedureURI, sShape.values[iItemPosition]);
2723
2749
              if (strcasecmp(pszProcedureURI, sosparams->pszProcedure) == 0) {
2724
2750
                pszUrl = msOWSLookupMetadata(&(lp->metadata), "S", "describesensor_url");
2725
 
                pszProcedureId = strdup(sShape.values[iItemPosition]);
 
2751
                pszProcedureId = msStrdup(sShape.values[iItemPosition]);
2726
2752
                if (pszUrl) {   
2727
 
                  pszTmp = strdup(pszUrl);
 
2753
                  pszTmp = msStrdup(pszUrl);
2728
2754
 
2729
2755
                  /* %procedure% is the hardcoded variable names to use
2730
2756
                     within sos_describesensor_url */
2731
2757
                  tmpstr = (char *)malloc(sizeof(char)*strlen("procedure") + 3);
2732
2758
                  sprintf(tmpstr,"%%%s%%", "procedure");
2733
 
                  if (msCaseFindSubstring(pszUrl, tmpstr) != NULL)
 
2759
                  if (strcasestr(pszUrl, tmpstr) != NULL)
2734
2760
                    pszTmp = msCaseReplaceSubstring(pszTmp, tmpstr, pszProcedureId);
2735
2761
                  msFree(tmpstr);
2736
2762
 
2759
2785
/*                                                                      */
2760
2786
/*      DescribeObserrvationType request handler                        */
2761
2787
/************************************************************************/
2762
 
int msSOSDescribeObservationType(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req) {
 
2788
int msSOSDescribeObservationType(mapObj *map, sosParamsObj *sosparams, cgiRequestObj *req, owsRequestObj *ows_request)
 
2789
{
2763
2790
  int i, j, n = 0, bLayerFound = 0;
2764
2791
  char **tokens = NULL;
2765
 
  const char *script_url=NULL;
 
2792
  char *script_url=NULL;
2766
2793
  const char *pszTmp = NULL;
2767
2794
  char *pszTmp2=NULL;
2768
2795
  const char *opLayerName = NULL;
2775
2802
  tokens = msStringSplit(sosparams->pszObservedProperty, ',', &n);
2776
2803
 
2777
2804
  for (i=0; i<map->numlayers; i++) {
 
2805
    if (!msIntegerInArray(GET_LAYER(map, i)->index, ows_request->enabled_layers, ows_request->numlayers))
 
2806
      continue;
2778
2807
    pszTmp = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "S", "observedproperty_id");
2779
2808
    if (pszTmp) {
2780
2809
      if (strcasecmp(pszTmp, sosparams->pszObservedProperty) == 0) {
2807
2836
 
2808
2837
  msIO_printf("Location: %s\n\n", pszTmp2);
2809
2838
  msFree(pszTmp2);
 
2839
  msFree(script_url);
2810
2840
  return(MS_SUCCESS);
2811
2841
}
2812
2842
 
2818
2848
** - If this is a valid request then it is processed and MS_SUCCESS is returned
2819
2849
**   on success, or MS_FAILURE on failure.
2820
2850
*/
2821
 
int msSOSDispatch(mapObj *map, cgiRequestObj *req) {
 
2851
int msSOSDispatch(mapObj *map, cgiRequestObj *req, owsRequestObj *ows_request) {
2822
2852
#if defined(USE_SOS_SVR) && defined(USE_LIBXML2)
2823
2853
  int returnvalue = MS_DONE;
2824
2854
  sosParamsObj *paramsObj = (sosParamsObj *)calloc(1, sizeof(sosParamsObj));
2836
2866
      return msSOSException(map, "request", "MissingParameterValue");
2837
2867
    }
2838
2868
 
 
2869
    msOWSRequestLayersEnabled(map, "S", paramsObj->pszRequest, ows_request);
 
2870
    if (ows_request->numlayers == 0)
 
2871
    {
 
2872
        msSetError(MS_SOSERR, "SOS request not enabled. Check sos/ows_enable_request settings.", "msSOSDispatch()");
 
2873
        msSOSFreeParamsObj(paramsObj);
 
2874
        free(paramsObj);
 
2875
        paramsObj = NULL;
 
2876
        return msSOSException(map, "request", "InvalidParameterValue");
 
2877
    }
 
2878
 
2839
2879
    if (strcasecmp(paramsObj->pszRequest, "GetCapabilities") == 0) {
2840
 
      returnvalue = msSOSGetCapabilities(map, paramsObj, req);
 
2880
      returnvalue = msSOSGetCapabilities(map, paramsObj, req, ows_request);
2841
2881
      msSOSFreeParamsObj(paramsObj);
2842
2882
      free(paramsObj);
2843
2883
      paramsObj = NULL;
2866
2906
      }
2867
2907
 
2868
2908
      if (strcasecmp(paramsObj->pszRequest, "DescribeSensor") == 0)
2869
 
        returnvalue = msSOSDescribeSensor(map, paramsObj);
 
2909
        returnvalue = msSOSDescribeSensor(map, paramsObj, ows_request);
2870
2910
 
2871
2911
      else if (strcasecmp(paramsObj->pszRequest, "GetObservation") == 0)
2872
 
        returnvalue = msSOSGetObservation(map, paramsObj, req);
 
2912
        returnvalue = msSOSGetObservation(map, paramsObj, req, ows_request);
2873
2913
 
2874
2914
      else if (strcasecmp(paramsObj->pszRequest, "DescribeObservationType") == 0)
2875
 
        returnvalue = msSOSDescribeObservationType(map, paramsObj, req);
 
2915
          returnvalue = msSOSDescribeObservationType(map, paramsObj, req, ows_request);
2876
2916
 
2877
2917
      msSOSFreeParamsObj(paramsObj);
2878
2918
      free(paramsObj);
2908
2948
  if (request->NumParams) { /* this is a GET request */
2909
2949
    for(i=0; i<request->NumParams; i++) {
2910
2950
      if (strcasecmp(request->ParamNames[i], "SERVICE") == 0)
2911
 
        sosparams->pszService = strdup(request->ParamValues[i]);
 
2951
        sosparams->pszService = msStrdup(request->ParamValues[i]);
2912
2952
      else if (strcasecmp(request->ParamNames[i], "VERSION") == 0)
2913
 
        sosparams->pszVersion = strdup(request->ParamValues[i]);
 
2953
        sosparams->pszVersion = msStrdup(request->ParamValues[i]);
2914
2954
      else if (strcasecmp(request->ParamNames[i], "ACCEPTVERSIONS") == 0)
2915
 
        sosparams->pszAcceptVersions = strdup(request->ParamValues[i]);
 
2955
        sosparams->pszAcceptVersions = msStrdup(request->ParamValues[i]);
2916
2956
      else if (strcasecmp(request->ParamNames[i], "REQUEST") == 0)
2917
 
        sosparams->pszRequest = strdup(request->ParamValues[i]);
 
2957
        sosparams->pszRequest = msStrdup(request->ParamValues[i]);
2918
2958
      else if (strcasecmp(request->ParamNames[i], "UPDATESEQUENCE") == 0)
2919
 
        sosparams->pszUpdateSequence = strdup(request->ParamValues[i]);
 
2959
        sosparams->pszUpdateSequence = msStrdup(request->ParamValues[i]);
2920
2960
      else  if (strcasecmp(request->ParamNames[i], "SENSORID") == 0)
2921
 
        sosparams->pszSensorId = strdup(request->ParamValues[i]);
 
2961
        sosparams->pszSensorId = msStrdup(request->ParamValues[i]);
2922
2962
      else  if (strcasecmp(request->ParamNames[i], "PROCEDURE") == 0)
2923
 
        sosparams->pszProcedure = strdup(request->ParamValues[i]);
 
2963
        sosparams->pszProcedure = msStrdup(request->ParamValues[i]);
2924
2964
      else if (strcasecmp(request->ParamNames[i], "OUTPUTFORMAT") == 0)
2925
 
        sosparams->pszOutputFormat = strdup(request->ParamValues[i]);
 
2965
        sosparams->pszOutputFormat = msStrdup(request->ParamValues[i]);
2926
2966
      else if (strcasecmp(request->ParamNames[i], "OFFERING") == 0)
2927
 
        sosparams->pszOffering = strdup(request->ParamValues[i]);
 
2967
        sosparams->pszOffering = msStrdup(request->ParamValues[i]);
2928
2968
      else if (strcasecmp(request->ParamNames[i], "OBSERVEDPROPERTY") == 0)
2929
 
        sosparams->pszObservedProperty = strdup(request->ParamValues[i]);
 
2969
        sosparams->pszObservedProperty = msStrdup(request->ParamValues[i]);
2930
2970
      else if (strcasecmp(request->ParamNames[i], "EVENTTIME") == 0)
2931
 
        sosparams->pszEventTime = strdup(request->ParamValues[i]);
 
2971
        sosparams->pszEventTime = msStrdup(request->ParamValues[i]);
2932
2972
      else if (strcasecmp(request->ParamNames[i], "RESULT") == 0)
2933
 
        sosparams->pszResult = strdup(request->ParamValues[i]);
 
2973
        sosparams->pszResult = msStrdup(request->ParamValues[i]);
2934
2974
      else if (strcasecmp(request->ParamNames[i], "RESULTMODEL") == 0)
2935
 
        sosparams->pszResultModel = strdup(request->ParamValues[i]);
 
2975
        sosparams->pszResultModel = msStrdup(request->ParamValues[i]);
2936
2976
      else if (strcasecmp(request->ParamNames[i], "RESPONSEFORMAT") == 0)
2937
 
        sosparams->pszResponseFormat = strdup(request->ParamValues[i]);
 
2977
        sosparams->pszResponseFormat = msStrdup(request->ParamValues[i]);
2938
2978
      else if (strcasecmp(request->ParamNames[i], "RESPONSEMODE") == 0)
2939
 
        sosparams->pszResponseMode = strdup(request->ParamValues[i]);
 
2979
        sosparams->pszResponseMode = msStrdup(request->ParamValues[i]);
2940
2980
      else if (strcasecmp(request->ParamNames[i], "BBOX") == 0)
2941
 
        sosparams->pszBBox = strdup(request->ParamValues[i]);
 
2981
        sosparams->pszBBox = msStrdup(request->ParamValues[i]);
2942
2982
      else if (strcasecmp(request->ParamNames[i], "SRSNAME") == 0)
2943
 
        sosparams->pszSrsName = strdup(request->ParamValues[i]);
 
2983
        sosparams->pszSrsName = msStrdup(request->ParamValues[i]);
2944
2984
      else if (strcasecmp(request->ParamNames[i], "FEATUREOFINTEREST") == 0)
2945
 
        sosparams->pszFeatureOfInterest = strdup(request->ParamValues[i]);
 
2985
        sosparams->pszFeatureOfInterest = msStrdup(request->ParamValues[i]);
2946
2986
    }
2947
2987
  }
2948
2988
 
3005
3045
    psXPathTmp = msLibXml2GetXPath(doc, context, (xmlChar *)"/sos:GetCapabilities");
3006
3046
 
3007
3047
    if (psXPathTmp)
3008
 
      sosparams->pszRequest = strdup("GetCapabilities");
 
3048
      sosparams->pszRequest = msStrdup("GetCapabilities");
3009
3049
 
3010
3050
    psXPathTmp = msLibXml2GetXPath(doc, context, (xmlChar *)"/sos:DescribeSensor");
3011
3051
 
3012
3052
    if (psXPathTmp)
3013
 
      sosparams->pszRequest = strdup("DescribeSensor");
 
3053
      sosparams->pszRequest = msStrdup("DescribeSensor");
3014
3054
 
3015
3055
    psXPathTmp = msLibXml2GetXPath(doc, context, (xmlChar *)"/sos:GetObservation");
3016
3056
 
3017
3057
    if (psXPathTmp)
3018
 
      sosparams->pszRequest = strdup("GetObservation");
 
3058
      sosparams->pszRequest = msStrdup("GetObservation");
3019
3059
 
3020
3060
    psXPathTmp = msLibXml2GetXPath(doc, context, (xmlChar *)"/sos:DescribeObservationType");
3021
3061
 
3022
3062
    if (psXPathTmp)
3023
 
      sosparams->pszRequest = strdup("DescribeObservationType");
 
3063
      sosparams->pszRequest = msStrdup("DescribeObservationType");
3024
3064
 
3025
3065
    xmlXPathFreeObject(psXPathTmp);
3026
3066
 
3118
3158
    psXPathTmp = msLibXml2GetXPath(doc, context, (xmlChar *)"/sos:GetObservation/sos:result/child::*");
3119
3159
 
3120
3160
    if (psXPathTmp) {
3121
 
      sosparams->pszResult = strdup(msLibXml2GetXPathTree(doc, psXPathTmp));
 
3161
      sosparams->pszResult = msStrdup(msLibXml2GetXPathTree(doc, psXPathTmp));
3122
3162
      pszTmp = msStringConcatenate(pszTmp, "<ogc:Filter>");
3123
3163
      pszTmp = msStringConcatenate(pszTmp, sosparams->pszResult);
3124
3164
      pszTmp = msStringConcatenate(pszTmp, "</ogc:Filter>");
3125
3165
      msFree(sosparams->pszResult); 
3126
 
      sosparams->pszResult = strdup(pszTmp);
 
3166
      sosparams->pszResult = msStrdup(pszTmp);
3127
3167
      msFree(pszTmp);
3128
3168
    }
3129
3169
 
3192
3232
  }
3193
3233
}
3194
3234
#endif /* defined(USE_SOS_SVR) && defined(USE_LIBXML2) */
3195