← Back to branch summary

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

« back to all changes in this revision

Viewing changes to mapwcs11.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:
mapwcs11.c
1
1
/******************************************************************************
2
 
 * $Id: mapwcs11.c 9498 2009-10-20 13:38:46Z aboudreault $
 
2
 * $Id: mapwcs11.c 11503 2011-04-07 19:56:16Z dmorissette $
3
3
 *
4
4
 * Project:  MapServer
5
5
 * Purpose:  OpenGIS Web Coverage Server (WCS) 1.1.0 Implementation.  This
35
35
#include "mapthread.h"
36
36
#include "mapwcs.h"
37
37
 
38
 
MS_CVSID("$Id: mapwcs11.c 9498 2009-10-20 13:38:46Z aboudreault $")
 
38
MS_CVSID("$Id: mapwcs11.c 11503 2011-04-07 19:56:16Z dmorissette $")
39
39
 
40
40
#if defined(USE_WCS_SVR) && defined(USE_LIBXML2)
41
41
 
114
114
static char *msWCSGetFormatsList11( mapObj *map, layerObj *layer )
115
115
 
116
116
{
117
 
    char *format_list = strdup("");
 
117
    char *format_list = msStrdup("");
118
118
    char **tokens = NULL, **formats = NULL;
119
119
    int  i, numtokens = 0, numformats;
120
120
    const char *value;
121
121
 
 
122
    msApplyDefaultOutputFormats(map);
 
123
 
122
124
/* -------------------------------------------------------------------- */
123
125
/*      Parse from layer metadata.                                      */
124
126
/* -------------------------------------------------------------------- */
125
127
    if( layer != NULL 
126
 
        && (value = msOWSGetEncodeMetadata( &(layer->metadata),"COM","formats",
 
128
        && (value = msOWSGetEncodeMetadata( &(layer->metadata),"CO","formats",
127
129
                                            "GTiff" )) != NULL ) {
128
130
        tokens = msStringSplit(value, ' ', &numtokens);
129
131
    }
143
145
              case MS_RENDER_WITH_GD:
144
146
              case MS_RENDER_WITH_AGG:
145
147
              case MS_RENDER_WITH_RAWDATA:
146
 
                tokens[numtokens++] = strdup(map->outputformatlist[i]->name);
 
148
                tokens[numtokens++] = msStrdup(map->outputformatlist[i]->name);
147
149
                break;
148
150
                
149
151
                /* rest of formats aren't really WCS compatible */
202
204
            continue;
203
205
        }
204
206
        
205
 
        formats[numformats++] = strdup(mimetype);
 
207
        formats[numformats++] = msStrdup(mimetype);
206
208
    }
207
209
 
208
210
    msFreeCharArray(tokens,numtokens);
213
215
/* -------------------------------------------------------------------- */
214
216
    for(i=0; i<numformats; i++) 
215
217
    {
216
 
        int       new_length;
217
 
        const char *format = formats[i];
218
 
            
219
 
        new_length = strlen(format_list) + strlen(format) + 2;
220
 
        format_list = (char *) realloc(format_list,new_length);
221
 
        
222
 
        if( strlen(format_list) > 0 )
223
 
            strcat( format_list, "," );
224
 
        strcat( format_list, format );
 
218
        if(i > 0)
 
219
        {
 
220
            format_list = msStringConcatenate(format_list, (char *) ",");
 
221
        }
 
222
        format_list = msStringConcatenate(format_list, formats[i]);
225
223
    }
226
224
    msFreeCharArray(formats,numformats);
227
225
 
258
256
/* -------------------------------------------------------------------- */
259
257
/*      Title (from description)                                        */
260
258
/* -------------------------------------------------------------------- */
261
 
    value = msOWSLookupMetadata( &(layer->metadata), "COM", "description");
 
259
    value = msOWSLookupMetadata( &(layer->metadata), "CO", "description");
262
260
    if( value == NULL )
263
 
        value = layer->name;
 
261
        value = msOWSLookupMetadata( &(layer->metadata), "CO", "title");
 
262
        if( value == NULL )
 
263
            value = layer->name;
264
264
    xmlNewChild( psCSummary, psOwsNs, BAD_CAST "Title", BAD_CAST value );
265
265
 
266
266
/* -------------------------------------------------------------------- */
267
267
/*      Abstract                                                        */
268
268
/* -------------------------------------------------------------------- */
269
 
    value = msOWSLookupMetadata( &(layer->metadata), "COM", "abstract");
 
269
    value = msOWSLookupMetadata( &(layer->metadata), "CO", "abstract");
270
270
    xmlNewChild( psCSummary, psOwsNs, BAD_CAST "Abstract", BAD_CAST value );
271
271
 
272
272
/* -------------------------------------------------------------------- */
273
273
/*      Keywords                                                        */
274
274
/* -------------------------------------------------------------------- */
275
 
    value = msOWSLookupMetadata(&(layer->metadata), "COM", "keywordlist");
 
275
    value = msOWSLookupMetadata(&(layer->metadata), "CO", "keywordlist");
276
276
 
277
277
    if (value) {
278
278
        xmlNodePtr psNode;
302
302
/* -------------------------------------------------------------------- */
303
303
    if( (owned_value = 
304
304
         msOWSGetProjURN( &(layer->projection), &(layer->metadata), 
305
 
                          "COM", MS_FALSE)) != NULL ) {
 
305
                          "CO", MS_FALSE)) != NULL ) {
306
306
        /* ok */
307
307
    } else if((owned_value = 
308
308
               msOWSGetProjURN( &(layer->map->projection), 
309
309
                                &(layer->map->web.metadata), 
310
 
                                "COM", MS_FALSE)) != NULL ) {
 
310
                                "CO", MS_FALSE)) != NULL ) {
311
311
        /* ok */
312
312
    } else 
313
313
        msDebug( "mapwcs.c: missing required information, no SRSs defined.\n");
341
341
/*                       msWCSGetCapabilities11()                       */
342
342
/************************************************************************/
343
343
int msWCSGetCapabilities11(mapObj *map, wcsParamsObj *params, 
344
 
                                  cgiRequestObj *req)
 
344
                           cgiRequestObj *req, owsRequestObj *ows_request)
345
345
{
346
346
    xmlDocPtr psDoc = NULL;       /* document pointer */
347
347
    xmlNodePtr psRootNode, psMainNode, psNode;
382
382
/* -------------------------------------------------------------------- */
383
383
/*      Build list of layer identifiers available.                      */
384
384
/* -------------------------------------------------------------------- */
385
 
    identifier_list = strdup("");
 
385
    identifier_list = msStrdup("");
386
386
    for(i=0; i<map->numlayers; i++)
387
387
    {
388
388
        layerObj *layer = map->layers[i];
426
426
      xmlNewProp(psRootNode, BAD_CAST "updateSequence", BAD_CAST updatesequence);
427
427
 
428
428
    schemaLocation = msEncodeHTMLEntities( msOWSGetSchemasLocation(map) );
429
 
    xsi_schemaLocation = strdup("http://www.opengis.net/wcs/1.1");
 
429
    xsi_schemaLocation = msStrdup("http://www.opengis.net/wcs/1.1");
430
430
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, " ");
431
431
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, schemaLocation);
432
432
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, "/wcs/1.1/wcsGetCapabilities.xsd ");
460
460
/*      Operations metadata.                                            */
461
461
/* -------------------------------------------------------------------- */
462
462
    /*operation metadata */
463
 
    if ((script_url=msOWSGetOnlineResource(map, "COM", "onlineresource", req)) == NULL 
 
463
    if ((script_url=msOWSGetOnlineResource(map, "CO", "onlineresource", req)) == NULL 
464
464
        || (script_url_encoded = msEncodeHTMLEntities(script_url)) == NULL)
465
465
    {
466
466
        msSetError(MS_WCSERR, "Server URL not found", "msWCSGetCapabilities11()");
479
479
/* -------------------------------------------------------------------- */
480
480
        psNode = msOWSCommonOperationsMetadataOperation( 
481
481
            psOwsNs, psXLinkNs,
482
 
            "GetCapabilities", OWS_METHOD_GET, script_url_encoded);
 
482
            "GetCapabilities", OWS_METHOD_GETPOST, script_url_encoded);
483
483
        
484
484
        xmlAddChild(psMainNode, psNode);
485
485
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
490
490
/* -------------------------------------------------------------------- */
491
491
/*      DescribeCoverage                                                */
492
492
/* -------------------------------------------------------------------- */
493
 
        psNode = msOWSCommonOperationsMetadataOperation(
494
 
            psOwsNs, psXLinkNs,
495
 
            "DescribeCoverage", OWS_METHOD_GET, script_url_encoded);
496
 
        
497
 
        xmlAddChild(psMainNode, psNode);
498
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
499
 
                        ows_version, psOwsNs, "Parameter", "service", "WCS"));
500
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
501
 
                        ows_version, psOwsNs, "Parameter", "version", (char *)params->version));
502
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
503
 
                        ows_version, psOwsNs, "Parameter", "identifiers", identifier_list ));
 
493
        if (msOWSRequestIsEnabled(map, NULL, "C", "DescribeCoverage", MS_TRUE)) 
 
494
        {
 
495
            psNode = msOWSCommonOperationsMetadataOperation(
 
496
                psOwsNs, psXLinkNs,
 
497
                "DescribeCoverage", OWS_METHOD_GETPOST, script_url_encoded);
 
498
            
 
499
            xmlAddChild(psMainNode, psNode);
 
500
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
501
                            ows_version, psOwsNs, "Parameter", "service", "WCS"));
 
502
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
503
                            ows_version, psOwsNs, "Parameter", "version", (char *)params->version));
 
504
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
505
                            ows_version, psOwsNs, "Parameter", "identifiers", identifier_list ));
 
506
        }
504
507
        
505
508
/* -------------------------------------------------------------------- */
506
509
/*      GetCoverage                                                     */
507
510
/* -------------------------------------------------------------------- */
508
 
        psNode = msOWSCommonOperationsMetadataOperation(
509
 
            psOwsNs, psXLinkNs,
510
 
            "GetCoverage", OWS_METHOD_GET, script_url_encoded);
511
 
        
512
 
        format_list = msWCSGetFormatsList11( map, NULL );
513
 
        
514
 
        xmlAddChild(psMainNode, psNode);
515
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
516
 
                        ows_version, psOwsNs, "Parameter", "service", "WCS"));
517
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
518
 
                        ows_version, psOwsNs, "Parameter", "version", (char *)params->version));
519
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
520
 
                        ows_version, psOwsNs, "Parameter", "Identifier", identifier_list ));
521
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
522
 
                        ows_version, psOwsNs, "Parameter", "InterpolationType", 
523
 
                        "NEAREST_NEIGHBOUR,BILINEAR" ));
524
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
525
 
                        ows_version, psOwsNs, "Parameter", "format", format_list ));
526
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
527
 
                        ows_version, psOwsNs, "Parameter", "store", "false" ));
528
 
        xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
529
 
                        ows_version, psOwsNs, "Parameter", "GridBaseCRS", 
530
 
                        "urn:ogc:def:crs:epsg::4326" ));
531
 
        
532
 
        msFree( format_list );
 
511
        if (msOWSRequestIsEnabled(map, NULL, "C", "GetCoverage", MS_TRUE)) 
 
512
        {
 
513
 
 
514
            psNode = msOWSCommonOperationsMetadataOperation(
 
515
                psOwsNs, psXLinkNs,
 
516
                "GetCoverage", OWS_METHOD_GETPOST, script_url_encoded);
 
517
            
 
518
            format_list = msWCSGetFormatsList11( map, NULL );
 
519
            
 
520
            xmlAddChild(psMainNode, psNode);
 
521
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
522
                            ows_version, psOwsNs, "Parameter", "service", "WCS"));
 
523
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
524
                            ows_version, psOwsNs, "Parameter", "version", (char *)params->version));
 
525
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
526
                            ows_version, psOwsNs, "Parameter", "Identifier", identifier_list ));
 
527
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
528
                            ows_version, psOwsNs, "Parameter", "InterpolationType", 
 
529
                            "NEAREST_NEIGHBOUR,BILINEAR" ));
 
530
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
531
                            ows_version, psOwsNs, "Parameter", "format", format_list ));
 
532
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
533
                            ows_version, psOwsNs, "Parameter", "store", "false" ));
 
534
            xmlAddChild(psNode, msOWSCommonOperationsMetadataDomainType(
 
535
                            ows_version, psOwsNs, "Parameter", "GridBaseCRS", 
 
536
                            "urn:ogc:def:crs:epsg::4326" ));
 
537
        
 
538
            msFree( format_list );
 
539
        }
533
540
    }    
534
541
 
535
542
/* -------------------------------------------------------------------- */
549
556
            if(!msWCSIsLayerSupported(layer)) 
550
557
                continue;
551
558
            
 
559
            if (!msIntegerInArray(layer->index, ows_request->enabled_layers, ows_request->numlayers))
 
560
                continue;
 
561
 
552
562
            status = msWCSGetCapabilities11_CoverageSummary( 
553
563
                map, params, req, psDoc, psMainNode, layer );
554
564
            if(status != MS_SUCCESS) return MS_FAILURE;
580
590
    xmlCleanupParser();
581
591
 
582
592
    /* clean up */
583
 
    msWCSFreeParams(params);
584
 
    free(params);
585
593
    free( script_url_encoded );
586
594
    free( identifier_list );
587
595
 
629
637
/* -------------------------------------------------------------------- */
630
638
/*      Title (from description)                                        */
631
639
/* -------------------------------------------------------------------- */
632
 
    value = msOWSLookupMetadata( &(layer->metadata), "COM", "description");
 
640
    value = msOWSLookupMetadata( &(layer->metadata), "CO", "description");
633
641
    if( value == NULL )
634
642
        value = layer->name;
635
643
    xmlNewChild( psCD, psOwsNs, BAD_CAST "Title", BAD_CAST value );
637
645
/* -------------------------------------------------------------------- */
638
646
/*      Abstract                                                        */
639
647
/* -------------------------------------------------------------------- */
640
 
    value = msOWSLookupMetadata( &(layer->metadata), "COM", "abstract");
 
648
    value = msOWSLookupMetadata( &(layer->metadata), "CO", "abstract");
641
649
    xmlNewChild( psCD, psOwsNs, BAD_CAST "Abstract", BAD_CAST value );
642
650
 
643
651
/* -------------------------------------------------------------------- */
644
652
/*      Keywords                                                        */
645
653
/* -------------------------------------------------------------------- */
646
 
    value = msOWSLookupMetadata(&(layer->metadata), "COM", "keywordlist");
 
654
    value = msOWSLookupMetadata(&(layer->metadata), "CO", "keywordlist");
647
655
 
648
656
    if (value)
649
657
        msLibXml2GenerateList( 
723
731
  /* TemporalDomain */
724
732
 
725
733
  /* TODO: figure out when a temporal domain is valid, for example only tiled rasters support time as a domain, plus we need a timeitem */
726
 
  if(msOWSLookupMetadata(&(layer->metadata), "COM", "timeposition") || msOWSLookupMetadata(&(layer->metadata), "COM", "timeperiod")) {
 
734
  if(msOWSLookupMetadata(&(layer->metadata), "CO", "timeposition") || msOWSLookupMetadata(&(layer->metadata), "CO", "timeperiod")) {
727
735
    msIO_printf("      <temporalDomain>\n");
728
736
 
729
737
    /* TimePosition (should support a value AUTO, then we could mine positions from the timeitem) */
730
 
    msOWSPrintEncodeMetadataList(stdout, &(layer->metadata), "COM", "timeposition", NULL, NULL, "        <gml:timePosition>%s</gml:timePosition>\n", NULL);    
 
738
    msOWSPrintEncodeMetadataList(stdout, &(layer->metadata), "CO", "timeposition", NULL, NULL, "        <gml:timePosition>%s</gml:timePosition>\n", NULL);    
731
739
 
732
740
    /* TODO:  add TimePeriod (only one per layer)  */
733
741
 
749
757
                xmlNewChild( psCD, NULL, BAD_CAST "Range", NULL ),
750
758
                NULL, BAD_CAST "Field", NULL );
751
759
        
752
 
        value = msOWSGetEncodeMetadata( &(layer->metadata), "COM", 
 
760
        value = msOWSGetEncodeMetadata( &(layer->metadata), "CO", 
753
761
                                        "rangeset_label", NULL );
754
762
        if( value )
755
763
            xmlNewChild( psField, psOwsNs, BAD_CAST "Title", BAD_CAST value );
756
764
 
757
765
        /* ows:Abstract? TODO */
758
766
 
759
 
        value = msOWSGetEncodeMetadata( &(layer->metadata), "COM", 
 
767
        value = msOWSGetEncodeMetadata( &(layer->metadata), "CO", 
760
768
                                        "rangeset_name", "raster" );
761
769
        xmlNewChild( psField, NULL, BAD_CAST "Identifier", BAD_CAST value );
762
770
       
764
772
            xmlNewChild(
765
773
                xmlNewChild( psField, NULL, BAD_CAST "Definition", NULL ),
766
774
                psOwsNs, BAD_CAST "AnyValue", NULL );
767
 
 
 
775
 
 
776
        /* NullValue */
 
777
        value = msOWSGetEncodeMetadata( &(layer->metadata), "CO", 
 
778
                                        "rangeset_nullvalue", NULL);
 
779
        if( value )
 
780
            xmlNewChild( psField, NULL, BAD_CAST "NullValue", 
 
781
                         BAD_CAST value );
 
782
 
 
783
        /* InterpolationMethods */
768
784
        psInterpMethods = 
769
785
            xmlNewChild( psField, NULL, BAD_CAST "InterpolationMethods", NULL );
770
786
 
772
788
        xmlNewChild( psInterpMethods, NULL, 
773
789
                     BAD_CAST "Default", BAD_CAST "nearest neighbor" );
774
790
 
775
 
 
776
791
/* -------------------------------------------------------------------- */
777
792
/*      Bands axis.                                                     */
778
793
/* -------------------------------------------------------------------- */
780
795
            xmlNodePtr psKeys;
781
796
            int iBand;
782
797
 
783
 
            value = msOWSGetEncodeMetadata( &(layer->metadata), "COM", 
 
798
            value = msOWSGetEncodeMetadata( &(layer->metadata), "CO", 
784
799
                                            "bands_name", "bands" );
785
800
            psAxis = xmlNewChild( psField, NULL, BAD_CAST "Axis", NULL );
786
801
            xmlNewProp( psAxis, BAD_CAST "identifier", BAD_CAST value );
792
807
            {
793
808
                char szBandName[32];
794
809
 
795
 
                sprintf( szBandName, "%d", iBand+1 );
 
810
                snprintf( szBandName, sizeof(szBandName), "%d", iBand+1 );
796
811
                xmlNewChild( psKeys, NULL, BAD_CAST "Key", 
797
812
                             BAD_CAST szBandName );
798
813
            }
807
822
        
808
823
        if( (owned_value = 
809
824
             msOWSGetProjURN( &(layer->projection), &(layer->metadata), 
810
 
                              "COM", MS_FALSE)) != NULL ) {
 
825
                              "CO", MS_FALSE)) != NULL ) {
811
826
            /* ok */
812
827
        } else if((owned_value = 
813
828
                   msOWSGetProjURN( &(layer->map->projection), 
814
829
                                    &(layer->map->web.metadata), 
815
 
                                    "COM", MS_FALSE)) != NULL ) {
 
830
                                    "CO", MS_FALSE)) != NULL ) {
816
831
            /* ok */
817
832
        } else 
818
833
            msDebug( "mapwcs.c: missing required information, no SRSs defined.\n");
846
861
/*                      msWCSDescribeCoverage11()                       */
847
862
/************************************************************************/
848
863
 
849
 
int msWCSDescribeCoverage11(mapObj *map, wcsParamsObj *params)
 
864
int msWCSDescribeCoverage11(mapObj *map, wcsParamsObj *params, owsRequestObj *ows_request)
850
865
{
851
866
    xmlDocPtr psDoc = NULL;       /* document pointer */
852
867
    xmlNodePtr psRootNode;
879
894
    if(params->coverages) { /* use the list */
880
895
        for( j = 0; params->coverages[j]; j++ ) {
881
896
            i = msGetLayerIndex(map, params->coverages[j]);
882
 
            if(i == -1) {
 
897
            if ( (i == -1) || 
 
898
                 (!msIntegerInArray(GET_LAYER(map, i)->index, ows_request->enabled_layers, ows_request->numlayers)) )
 
899
            {
883
900
                msSetError( MS_WCSERR,
884
901
                            "COVERAGE %s cannot be opened / does not exist",
885
902
                            "msWCSDescribeCoverage()", params->coverages[j]);
907
924
    xmlNewNs(psRootNode, BAD_CAST MS_OWSCOMMON_OGC_NAMESPACE_URI, BAD_CAST MS_OWSCOMMON_OGC_NAMESPACE_PREFIX );
908
925
 
909
926
    schemaLocation = msEncodeHTMLEntities( msOWSGetSchemasLocation(map) );
910
 
    xsi_schemaLocation = strdup("http://www.opengis.net/wcs/1.1");
 
927
    xsi_schemaLocation = msStrdup("http://www.opengis.net/wcs/1.1");
911
928
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, " ");
912
929
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, schemaLocation);
913
930
    xsi_schemaLocation = msStringConcatenate(xsi_schemaLocation, "/wcs/1.1/wcsDescribeCoverage.xsd ");
929
946
                                                        psOwsNs );
930
947
        }
931
948
    } else { /* return all layers */
932
 
        for(i=0; i<map->numlayers; i++)
 
949
        for(i=0; i<map->numlayers; i++) {
 
950
 
 
951
            if (!msIntegerInArray(GET_LAYER(map, i)->index, ows_request->enabled_layers, ows_request->numlayers))
 
952
                continue;
 
953
 
933
954
            msWCSDescribeCoverage_CoverageDescription11((GET_LAYER(map, i)), 
934
955
                                                        params, psRootNode,
935
956
                                                        psOwsNs );
 
957
        }
936
958
    }
937
959
  
938
960
/* -------------------------------------------------------------------- */
963
985
/* -------------------------------------------------------------------- */
964
986
    xmlFreeDoc(psDoc);
965
987
    xmlCleanupParser();
966
 
    msWCSFreeParams(params);
967
 
 
968
 
    free(params);
969
988
 
970
989
    return MS_SUCCESS;
971
990
}
1005
1024
    if( value == NULL )
1006
1025
        return MS_SUCCESS;
1007
1026
 
1008
 
    rangesubset = strdup(value);
 
1027
    rangesubset = msStrdup(value);
1009
1028
 
1010
1029
/* -------------------------------------------------------------------- */
1011
1030
/*      What is the <Field identifier=...> (rangeset_name)?             */
1012
1031
/* -------------------------------------------------------------------- */
1013
 
    value = msOWSLookupMetadata( &(lp->metadata), "COM", "rangeset_name" );
 
1032
    value = msOWSLookupMetadata( &(lp->metadata), "CO", "rangeset_name" );
1014
1033
    if( value == NULL )
1015
1034
        value = "raster";
1016
 
    field_id = strdup(value);
 
1035
    field_id = msStrdup(value);
1017
1036
 
1018
1037
/* -------------------------------------------------------------------- */
1019
1038
/*      What is the <Axis identifier=...> (bands_name)?                 */
1020
1039
/* -------------------------------------------------------------------- */
1021
 
    axis_id = msOWSLookupMetadata( &(lp->metadata), "COM", "bands_name" );
 
1040
    axis_id = msOWSLookupMetadata( &(lp->metadata), "CO", "bands_name" );
1022
1041
    if( axis_id == NULL )
1023
1042
        axis_id = "bands";
1024
1043
 
1050
1069
    if( *value == ':' )
1051
1070
    {
1052
1071
        assert( params->interpolation == NULL );
1053
 
        params->interpolation = strdup(value+1);
 
1072
        params->interpolation = msStrdup(value+1);
1054
1073
        for( i = 0; params->interpolation[i] != '\0'; i++ )
1055
1074
        {
1056
1075
            if( params->interpolation[i] == '[' )
1088
1107
/* -------------------------------------------------------------------- */
1089
1108
    value += strlen(axis_id) + 1;
1090
1109
 
1091
 
    *p_bandlist = strdup(value);
 
1110
    *p_bandlist = msStrdup(value);
1092
1111
 
1093
1112
    for( i = 0; (*p_bandlist)[i] != '\0'; i++ )
1094
1113
    {
1117
1136
    int status, i;
1118
1137
    char *filename = NULL;
1119
1138
    const char *encoding;
 
1139
    const char *fo_filename;
1120
1140
 
1121
1141
    encoding = msOWSLookupMetadata(&(map->web.metadata), "CO", "encoding");
1122
1142
 
 
1143
    fo_filename = msGetOutputFormatOption( image->format, "FILENAME", NULL );
 
1144
        
1123
1145
/* -------------------------------------------------------------------- */
1124
1146
/*      Fetch the driver we will be using and check if it supports      */
1125
1147
/*      VSIL IO.                                                        */
1149
1171
        if( GDALGetMetadataItem( hDriver, GDAL_DCAP_VIRTUALIO, NULL ) 
1150
1172
            != NULL )
1151
1173
        {
 
1174
            if( fo_filename )
 
1175
                filename = msStrdup(CPLFormFilename("/vsimem/wcsout",
 
1176
                                                    fo_filename,NULL));
 
1177
            else
 
1178
                filename = msStrdup(CPLFormFilename("/vsimem/wcsout", 
 
1179
                                                    "out", pszExtension ));
 
1180
 
1152
1181
/*            CleanVSIDir( "/vsimem/wcsout" ); */
1153
 
            filename = strdup(CPLFormFilename("/vsimem/wcsout", 
1154
 
                                              "out", pszExtension ));
1155
 
 
 
1182
            
1156
1183
            msReleaseLock( TLOCK_GDAL );
1157
1184
            status = msSaveImage(map, image, filename);
1158
1185
            if( status != MS_SUCCESS )
1235
1262
            return msWCSException11(map, "mapserv", "NoApplicableCode", params->version);
1236
1263
        }
1237
1264
 
1238
 
        msIO_fprintf( stdout, "--wcs--%c%c", 10, 10 );
 
1265
        msIO_fprintf( stdout, "\n--wcs--%c%c", 10, 10 );
1239
1266
        return MS_SUCCESS;
1240
1267
    }
1241
1268
 
1331
1358
        CSLDestroy( all_files );
1332
1359
        msReleaseLock( TLOCK_GDAL );
1333
1360
 
1334
 
        msIO_fprintf( stdout, "--wcs--%c%c", 10, 10 );
 
1361
        msIO_fprintf( stdout, "\n--wcs--%c%c", 10, 10 );
1335
1362
        return MS_SUCCESS;
1336
1363
    }
1337
 
#endif /* def GDAL_DCAP_VIRTUALIO */    
 
1364
#else
 
1365
    return MS_SUCCESS;
 
1366
#endif /* def GDAL_DCAP_VIRTUALIO */
1338
1367
}
1339
1368
#endif /* defined(USE_WCS_SVR) && defined(USE_LIBXML2) */
1340
1369
 
1373
1402
    return msWCSException11(map, "mapserv", "NoApplicableCode", params->version);
1374
1403
}
1375
1404
 
1376
 
int msWCSException11(mapObj *map, char *locator, char *exceptionCode, const char *version) {
 
1405
int msWCSException11(mapObj *map, const char *locator, const char *exceptionCode, const char *version) {
1377
1406
    /* fallback to reporting using 1.0 style exceptions. */
1378
1407
    return msWCSException( map, locator, exceptionCode, "1.0.0" );
1379
1408
}