Index: trunk/zoo-project/zoo-kernel/Makefile.in
===================================================================
--- trunk/zoo-project/zoo-kernel/Makefile.in	(revision 600)
+++ trunk/zoo-project/zoo-kernel/Makefile.in	(revision 601)
@@ -33,5 +33,5 @@
 	gcc -fPIC ${XML2CFLAGS} ${CFLAGS} ${JSCFLAGS} ${JS_ENABLED} -c ulinet.c
 
-service_internal.o: service_internal.c service.h
+service_internal.o: service_internal.c service.h mimetypes.h
 	g++ ${GDAL_CFLAGS} ${JS_ENABLED} ${JSCFLAGS} ${XML2CFLAGS} ${CFLAGS} -fPIC -c service_internal.c
 
Index: trunk/zoo-project/zoo-kernel/makefile.vc
===================================================================
--- trunk/zoo-project/zoo-kernel/makefile.vc	(revision 600)
+++ trunk/zoo-project/zoo-kernel/makefile.vc	(revision 601)
@@ -41,5 +41,5 @@
 	$(CPP) $(CFLAGS) /c zcfg2yaml.c
 
-service_internal.obj: service_internal.c
+service_internal.obj: service_internal.c mimetypes.h
 	$(CPP) $(CFLAGS) /c service_internal.c
 
Index: trunk/zoo-project/zoo-kernel/mimetypes.h
===================================================================
--- trunk/zoo-project/zoo-kernel/mimetypes.h	(revision 601)
+++ trunk/zoo-project/zoo-kernel/mimetypes.h	(revision 601)
@@ -0,0 +1,837 @@
+#include "service.h"
+ 
+typedef enum MimeTypes {
+	 M_Type,
+	 M_Extension
+} mimetype;
+
+#define NUM_MIME_TYPES 767
+
+/*
+ * This array has been constructed based on the
+ * Apache web server's mime.types file
+ */
+const char* const MIME[NUM_MIME_TYPES][2] = {
+	{ "application/andrew-inset", "ez" },
+	{ "application/applixware", "aw" },
+	{ "application/atom+xml", "atom" },
+	{ "application/atomcat+xml", "atomcat" },
+	{ "application/atomsvc+xml", "atomsvc" },
+	{ "application/ccxml+xml", "ccxml" },
+	{ "application/cdmi-capability", "cdmia" },
+	{ "application/cdmi-container", "cdmic" },
+	{ "application/cdmi-domain", "cdmid" },
+	{ "application/cdmi-object", "cdmio" },
+	{ "application/cdmi-queue", "cdmiq" },
+	{ "application/cu-seeme", "cu" },
+	{ "application/davmount+xml", "davmount" },
+	{ "application/docbook+xml", "dbk" },
+	{ "application/dssc+der", "dssc" },
+	{ "application/dssc+xml", "xdssc" },
+	{ "application/ecmascript", "ecma" },
+	{ "application/emma+xml", "emma" },
+	{ "application/epub+zip", "epub" },
+	{ "application/exi", "exi" },
+	{ "application/font-tdpfr", "pfr" },
+	{ "application/gml+xml", "gml" },
+	{ "application/gpx+xml", "gpx" },
+	{ "application/gxf", "gxf" },
+	{ "application/hyperstudio", "stk" },
+	{ "application/inkml+xml", "ink" },
+	{ "application/ipfix", "ipfix" },
+	{ "application/java-archive", "jar" },
+	{ "application/java-serialized-object", "ser" },
+	{ "application/java-vm", "class" },
+	{ "application/javascript", "js" },
+	{ "application/json", "json" },
+	{ "application/jsonml+json", "jsonml" },
+	{ "application/lost+xml", "lostxml" },
+	{ "application/mac-binhex40", "hqx" },
+	{ "application/mac-compactpro", "cpt" },
+	{ "application/mads+xml", "mads" },
+	{ "application/marc", "mrc" },
+	{ "application/marcxml+xml", "mrcx" },
+	{ "application/mathematica", "ma" },
+	{ "application/mathml+xml", "mathml" },
+	{ "application/mbox", "mbox" },
+	{ "application/mediaservercontrol+xml", "mscml" },
+	{ "application/metalink+xml", "metalink" },
+	{ "application/metalink4+xml", "meta4" },
+	{ "application/mets+xml", "mets" },
+	{ "application/mods+xml", "mods" },
+	{ "application/mp21", "m21" },
+	{ "application/mp4", "mp4s" },
+	{ "application/msword", "doc" },
+	{ "application/mxf", "mxf" },
+	{ "application/octet-stream", "bin" },
+	{ "application/oda", "oda" },
+	{ "application/oebps-package+xml", "opf" },
+	{ "application/ogg", "ogx" },
+	{ "application/omdoc+xml", "omdoc" },
+	{ "application/onenote", "onetoc" },
+	{ "application/oxps", "oxps" },
+	{ "application/patch-ops-error+xml", "xer" },
+	{ "application/pdf", "pdf" },
+	{ "application/pgp-encrypted", "pgp" },
+	{ "application/pgp-signature", "asc" },
+	{ "application/pics-rules", "prf" },
+	{ "application/pkcs10", "p10" },
+	{ "application/pkcs7-mime", "p7m" },
+	{ "application/pkcs7-signature", "p7s" },
+	{ "application/pkcs8", "p8" },
+	{ "application/pkix-attr-cert", "ac" },
+	{ "application/pkix-cert", "cer" },
+	{ "application/pkix-crl", "crl" },
+	{ "application/pkix-pkipath", "pkipath" },
+	{ "application/pkixcmp", "pki" },
+	{ "application/pls+xml", "pls" },
+	{ "application/postscript", "ps" },
+	{ "application/prs.cww", "cww" },
+	{ "application/pskc+xml", "pskcxml" },
+	{ "application/rdf+xml", "rdf" },
+	{ "application/reginfo+xml", "rif" },
+	{ "application/relax-ng-compact-syntax", "rnc" },
+	{ "application/resource-lists+xml", "rl" },
+	{ "application/resource-lists-diff+xml", "rld" },
+	{ "application/rls-services+xml", "rs" },
+	{ "application/rpki-ghostbusters", "gbr" },
+	{ "application/rpki-manifest", "mft" },
+	{ "application/rpki-roa", "roa" },
+	{ "application/rsd+xml", "rsd" },
+	{ "application/rss+xml", "rss" },
+	{ "application/rtf", "rtf" },
+	{ "application/sbml+xml", "sbml" },
+	{ "application/scvp-cv-request", "scq" },
+	{ "application/scvp-cv-response", "scs" },
+	{ "application/scvp-vp-request", "spq" },
+	{ "application/scvp-vp-response", "spp" },
+	{ "application/sdp", "sdp" },
+	{ "application/set-payment-initiation", "setpay" },
+	{ "application/set-registration-initiation", "setreg" },
+	{ "application/shf+xml", "shf" },
+	{ "application/smil+xml", "smi" },
+	{ "application/sparql-query", "rq" },
+	{ "application/sparql-results+xml", "srx" },
+	{ "application/srgs", "gram" },
+	{ "application/srgs+xml", "grxml" },
+	{ "application/sru+xml", "sru" },
+	{ "application/ssdl+xml", "ssdl" },
+	{ "application/ssml+xml", "ssml" },
+	{ "application/tei+xml", "tei" },
+	{ "application/thraud+xml", "tfi" },
+	{ "application/timestamped-data", "tsd" },
+	{ "application/vnd.3gpp.pic-bw-large", "plb" },
+	{ "application/vnd.3gpp.pic-bw-small", "psb" },
+	{ "application/vnd.3gpp.pic-bw-var", "pvb" },
+	{ "application/vnd.3gpp2.tcap", "tcap" },
+	{ "application/vnd.3m.post-it-notes", "pwn" },
+	{ "application/vnd.accpac.simply.aso", "aso" },
+	{ "application/vnd.accpac.simply.imp", "imp" },
+	{ "application/vnd.acucobol", "acu" },
+	{ "application/vnd.acucorp", "atc" },
+	{ "application/vnd.adobe.air-application-installer-package+zip", "air" },
+	{ "application/vnd.adobe.formscentral.fcdt", "fcdt" },
+	{ "application/vnd.adobe.fxp", "fxp" },
+	{ "application/vnd.adobe.xdp+xml", "xdp" },
+	{ "application/vnd.adobe.xfdf", "xfdf" },
+	{ "application/vnd.ahead.space", "ahead" },
+	{ "application/vnd.airzip.filesecure.azf", "azf" },
+	{ "application/vnd.airzip.filesecure.azs", "azs" },
+	{ "application/vnd.amazon.ebook", "azw" },
+	{ "application/vnd.americandynamics.acc", "acc" },
+	{ "application/vnd.amiga.ami", "ami" },
+	{ "application/vnd.android.package-archive", "apk" },
+	{ "application/vnd.anser-web-certificate-issue-initiation", "cii" },
+	{ "application/vnd.anser-web-funds-transfer-initiation", "fti" },
+	{ "application/vnd.antix.game-component", "atx" },
+	{ "application/vnd.apple.installer+xml", "mpkg" },
+	{ "application/vnd.apple.mpegurl", "m3u8" },
+	{ "application/vnd.aristanetworks.swi", "swi" },
+	{ "application/vnd.astraea-software.iota", "iota" },
+	{ "application/vnd.audiograph", "aep" },
+	{ "application/vnd.blueice.multipass", "mpm" },
+	{ "application/vnd.bmi", "bmi" },
+	{ "application/vnd.businessobjects", "rep" },
+	{ "application/vnd.chemdraw+xml", "cdxml" },
+	{ "application/vnd.chipnuts.karaoke-mmd", "mmd" },
+	{ "application/vnd.cinderella", "cdy" },
+	{ "application/vnd.claymore", "cla" },
+	{ "application/vnd.cloanto.rp9", "rp9" },
+	{ "application/vnd.clonk.c4group", "c4g" },
+	{ "application/vnd.cluetrust.cartomobile-config", "c11amc" },
+	{ "application/vnd.cluetrust.cartomobile-config-pkg", "c11amz" },
+	{ "application/vnd.commonspace", "csp" },
+	{ "application/vnd.contact.cmsg", "cdbcmsg" },
+	{ "application/vnd.cosmocaller", "cmc" },
+	{ "application/vnd.crick.clicker", "clkx" },
+	{ "application/vnd.crick.clicker.keyboard", "clkk" },
+	{ "application/vnd.crick.clicker.palette", "clkp" },
+	{ "application/vnd.crick.clicker.template", "clkt" },
+	{ "application/vnd.crick.clicker.wordbank", "clkw" },
+	{ "application/vnd.criticaltools.wbs+xml", "wbs" },
+	{ "application/vnd.ctc-posml", "pml" },
+	{ "application/vnd.cups-ppd", "ppd" },
+	{ "application/vnd.curl.car", "car" },
+	{ "application/vnd.curl.pcurl", "pcurl" },
+	{ "application/vnd.dart", "dart" },
+	{ "application/vnd.data-vision.rdz", "rdz" },
+	{ "application/vnd.dece.data", "uvf" },
+	{ "application/vnd.dece.ttml+xml", "uvt" },
+	{ "application/vnd.dece.unspecified", "uvx" },
+	{ "application/vnd.dece.zip", "uvz" },
+	{ "application/vnd.denovo.fcselayout-link", "fe_launch" },
+	{ "application/vnd.dna", "dna" },
+	{ "application/vnd.dolby.mlp", "mlp" },
+	{ "application/vnd.dpgraph", "dpg" },
+	{ "application/vnd.dreamfactory", "dfac" },
+	{ "application/vnd.ds-keypoint", "kpxx" },
+	{ "application/vnd.dvb.ait", "ait" },
+	{ "application/vnd.dvb.service", "svc" },
+	{ "application/vnd.dynageo", "geo" },
+	{ "application/vnd.ecowin.chart", "mag" },
+	{ "application/vnd.enliven", "nml" },
+	{ "application/vnd.epson.esf", "esf" },
+	{ "application/vnd.epson.msf", "msf" },
+	{ "application/vnd.epson.quickanime", "qam" },
+	{ "application/vnd.epson.salt", "slt" },
+	{ "application/vnd.epson.ssf", "ssf" },
+	{ "application/vnd.eszigno3+xml", "es3" },
+	{ "application/vnd.ezpix-album", "ez2" },
+	{ "application/vnd.ezpix-package", "ez3" },
+	{ "application/vnd.fdf", "fdf" },
+	{ "application/vnd.fdsn.mseed", "mseed" },
+	{ "application/vnd.fdsn.seed", "seed" },
+	{ "application/vnd.flographit", "gph" },
+	{ "application/vnd.fluxtime.clip", "ftc" },
+	{ "application/vnd.framemaker", "fm" },
+	{ "application/vnd.frogans.fnc", "fnc" },
+	{ "application/vnd.frogans.ltf", "ltf" },
+	{ "application/vnd.fsc.weblaunch", "fsc" },
+	{ "application/vnd.fujitsu.oasys", "oas" },
+	{ "application/vnd.fujitsu.oasys2", "oa2" },
+	{ "application/vnd.fujitsu.oasys3", "oa3" },
+	{ "application/vnd.fujitsu.oasysgp", "fg5" },
+	{ "application/vnd.fujitsu.oasysprs", "bh2" },
+	{ "application/vnd.fujixerox.ddd", "ddd" },
+	{ "application/vnd.fujixerox.docuworks", "xdw" },
+	{ "application/vnd.fujixerox.docuworks.binder", "xbd" },
+	{ "application/vnd.fuzzysheet", "fzs" },
+	{ "application/vnd.genomatix.tuxedo", "txd" },
+	{ "application/vnd.geogebra.file", "ggb" },
+	{ "application/vnd.geogebra.tool", "ggt" },
+	{ "application/vnd.geometry-explorer", "gex" },
+	{ "application/vnd.geonext", "gxt" },
+	{ "application/vnd.geoplan", "g2w" },
+	{ "application/vnd.geospace", "g3w" },
+	{ "application/vnd.gmx", "gmx" },
+	{ "application/vnd.google-earth.kml+xml", "kml" },
+	{ "application/vnd.google-earth.kmz", "kmz" },
+	{ "application/vnd.grafeq", "gqf" },
+	{ "application/vnd.groove-account", "gac" },
+	{ "application/vnd.groove-help", "ghf" },
+	{ "application/vnd.groove-identity-message", "gim" },
+	{ "application/vnd.groove-injector", "grv" },
+	{ "application/vnd.groove-tool-message", "gtm" },
+	{ "application/vnd.groove-tool-template", "tpl" },
+	{ "application/vnd.groove-vcard", "vcg" },
+	{ "application/vnd.hal+xml", "hal" },
+	{ "application/vnd.handheld-entertainment+xml", "zmm" },
+	{ "application/vnd.hbci", "hbci" },
+	{ "application/vnd.hhe.lesson-player", "les" },
+	{ "application/vnd.hp-hpgl", "hpgl" },
+	{ "application/vnd.hp-hpid", "hpid" },
+	{ "application/vnd.hp-hps", "hps" },
+	{ "application/vnd.hp-jlyt", "jlt" },
+	{ "application/vnd.hp-pcl", "pcl" },
+	{ "application/vnd.hp-pclxl", "pclxl" },
+	{ "application/vnd.hydrostatix.sof-data", "sfd-hdstx" },
+	{ "application/vnd.ibm.minipay", "mpy" },
+	{ "application/vnd.ibm.modcap", "afp" },
+	{ "application/vnd.ibm.rights-management", "irm" },
+	{ "application/vnd.ibm.secure-container", "sc" },
+	{ "application/vnd.iccprofile", "icc" },
+	{ "application/vnd.igloader", "igl" },
+	{ "application/vnd.immervision-ivp", "ivp" },
+	{ "application/vnd.immervision-ivu", "ivu" },
+	{ "application/vnd.insors.igm", "igm" },
+	{ "application/vnd.intercon.formnet", "xpw" },
+	{ "application/vnd.intergeo", "i2g" },
+	{ "application/vnd.intu.qbo", "qbo" },
+	{ "application/vnd.intu.qfx", "qfx" },
+	{ "application/vnd.ipunplugged.rcprofile", "rcprofile" },
+	{ "application/vnd.irepository.package+xml", "irp" },
+	{ "application/vnd.is-xpr", "xpr" },
+	{ "application/vnd.isac.fcs", "fcs" },
+	{ "application/vnd.jam", "jam" },
+	{ "application/vnd.jcp.javame.midlet-rms", "rms" },
+	{ "application/vnd.jisp", "jisp" },
+	{ "application/vnd.joost.joda-archive", "joda" },
+	{ "application/vnd.kahootz", "ktz" },
+	{ "application/vnd.kde.karbon", "karbon" },
+	{ "application/vnd.kde.kchart", "chrt" },
+	{ "application/vnd.kde.kformula", "kfo" },
+	{ "application/vnd.kde.kivio", "flw" },
+	{ "application/vnd.kde.kontour", "kon" },
+	{ "application/vnd.kde.kpresenter", "kpr" },
+	{ "application/vnd.kde.kspread", "ksp" },
+	{ "application/vnd.kde.kword", "kwd" },
+	{ "application/vnd.kenameaapp", "htke" },
+	{ "application/vnd.kidspiration", "kia" },
+	{ "application/vnd.kinar", "kne" },
+	{ "application/vnd.koan", "skp" },
+	{ "application/vnd.kodak-descriptor", "sse" },
+	{ "application/vnd.las.las+xml", "lasxml" },
+	{ "application/vnd.llamagraphics.life-balance.desktop", "lbd" },
+	{ "application/vnd.llamagraphics.life-balance.exchange+xml", "lbe" },
+	{ "application/vnd.lotus-1-2-3", "123" },
+	{ "application/vnd.lotus-approach", "apr" },
+	{ "application/vnd.lotus-freelance", "pre" },
+	{ "application/vnd.lotus-notes", "nsf" },
+	{ "application/vnd.lotus-organizer", "org" },
+	{ "application/vnd.lotus-screencam", "scm" },
+	{ "application/vnd.lotus-wordpro", "lwp" },
+	{ "application/vnd.macports.portpkg", "portpkg" },
+	{ "application/vnd.mcd", "mcd" },
+	{ "application/vnd.medcalcdata", "mc1" },
+	{ "application/vnd.mediastation.cdkey", "cdkey" },
+	{ "application/vnd.mfer", "mwf" },
+	{ "application/vnd.mfmp", "mfm" },
+	{ "application/vnd.micrografx.flo", "flo" },
+	{ "application/vnd.micrografx.igx", "igx" },
+	{ "application/vnd.mif", "mif" },
+	{ "application/vnd.mobius.daf", "daf" },
+	{ "application/vnd.mobius.dis", "dis" },
+	{ "application/vnd.mobius.mbk", "mbk" },
+	{ "application/vnd.mobius.mqy", "mqy" },
+	{ "application/vnd.mobius.msl", "msl" },
+	{ "application/vnd.mobius.plc", "plc" },
+	{ "application/vnd.mobius.txf", "txf" },
+	{ "application/vnd.mophun.application", "mpn" },
+	{ "application/vnd.mophun.certificate", "mpc" },
+	{ "application/vnd.mozilla.xul+xml", "xul" },
+	{ "application/vnd.ms-artgalry", "cil" },
+	{ "application/vnd.ms-cab-compressed", "cab" },
+	{ "application/vnd.ms-excel", "xls" },
+	{ "application/vnd.ms-excel.addin.macroenabled.12", "xlam" },
+	{ "application/vnd.ms-excel.sheet.binary.macroenabled.12", "xlsb" },
+	{ "application/vnd.ms-excel.sheet.macroenabled.12", "xlsm" },
+	{ "application/vnd.ms-excel.template.macroenabled.12", "xltm" },
+	{ "application/vnd.ms-fontobject", "eot" },
+	{ "application/vnd.ms-htmlhelp", "chm" },
+	{ "application/vnd.ms-ims", "ims" },
+	{ "application/vnd.ms-lrm", "lrm" },
+	{ "application/vnd.ms-officetheme", "thmx" },
+	{ "application/vnd.ms-pki.seccat", "cat" },
+	{ "application/vnd.ms-pki.stl", "stl" },
+	{ "application/vnd.ms-powerpoint", "ppt" },
+	{ "application/vnd.ms-powerpoint.addin.macroenabled.12", "ppam" },
+	{ "application/vnd.ms-powerpoint.presentation.macroenabled.12", "pptm" },
+	{ "application/vnd.ms-powerpoint.slide.macroenabled.12", "sldm" },
+	{ "application/vnd.ms-powerpoint.slideshow.macroenabled.12", "ppsm" },
+	{ "application/vnd.ms-powerpoint.template.macroenabled.12", "potm" },
+	{ "application/vnd.ms-project", "mpp" },
+	{ "application/vnd.ms-word.document.macroenabled.12", "docm" },
+	{ "application/vnd.ms-word.template.macroenabled.12", "dotm" },
+	{ "application/vnd.ms-works", "wps" },
+	{ "application/vnd.ms-wpl", "wpl" },
+	{ "application/vnd.ms-xpsdocument", "xps" },
+	{ "application/vnd.mseq", "mseq" },
+	{ "application/vnd.musician", "mus" },
+	{ "application/vnd.muvee.style", "msty" },
+	{ "application/vnd.mynfc", "taglet" },
+	{ "application/vnd.neurolanguage.nlu", "nlu" },
+	{ "application/vnd.nitf", "ntf" },
+	{ "application/vnd.noblenet-directory", "nnd" },
+	{ "application/vnd.noblenet-sealer", "nns" },
+	{ "application/vnd.noblenet-web", "nnw" },
+	{ "application/vnd.nokia.n-gage.data", "ngdat" },
+	{ "application/vnd.nokia.n-gage.symbian.install", "n-gage" },
+	{ "application/vnd.nokia.radio-preset", "rpst" },
+	{ "application/vnd.nokia.radio-presets", "rpss" },
+	{ "application/vnd.novadigm.edm", "edm" },
+	{ "application/vnd.novadigm.edx", "edx" },
+	{ "application/vnd.novadigm.ext", "ext" },
+	{ "application/vnd.oasis.opendocument.chart", "odc" },
+	{ "application/vnd.oasis.opendocument.chart-template", "otc" },
+	{ "application/vnd.oasis.opendocument.database", "odb" },
+	{ "application/vnd.oasis.opendocument.formula", "odf" },
+	{ "application/vnd.oasis.opendocument.formula-template", "odft" },
+	{ "application/vnd.oasis.opendocument.graphics", "odg" },
+	{ "application/vnd.oasis.opendocument.graphics-template", "otg" },
+	{ "application/vnd.oasis.opendocument.image", "odi" },
+	{ "application/vnd.oasis.opendocument.image-template", "oti" },
+	{ "application/vnd.oasis.opendocument.presentation", "odp" },
+	{ "application/vnd.oasis.opendocument.presentation-template", "otp" },
+	{ "application/vnd.oasis.opendocument.spreadsheet", "ods" },
+	{ "application/vnd.oasis.opendocument.spreadsheet-template", "ots" },
+	{ "application/vnd.oasis.opendocument.text", "odt" },
+	{ "application/vnd.oasis.opendocument.text-master", "odm" },
+	{ "application/vnd.oasis.opendocument.text-template", "ott" },
+	{ "application/vnd.oasis.opendocument.text-web", "oth" },
+	{ "application/vnd.olpc-sugar", "xo" },
+	{ "application/vnd.oma.dd2+xml", "dd2" },
+	{ "application/vnd.openofficeorg.extension", "oxt" },
+	{ "application/vnd.openxmlformats-officedocument.presentationml.presentation", "pptx" },
+	{ "application/vnd.openxmlformats-officedocument.presentationml.slide", "sldx" },
+	{ "application/vnd.openxmlformats-officedocument.presentationml.slideshow", "ppsx" },
+	{ "application/vnd.openxmlformats-officedocument.presentationml.template", "potx" },
+	{ "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx" },
+	{ "application/vnd.openxmlformats-officedocument.spreadsheetml.template", "xltx" },
+	{ "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "docx" },
+	{ "application/vnd.openxmlformats-officedocument.wordprocessingml.template", "dotx" },
+	{ "application/vnd.osgeo.mapguide.package", "mgp" },
+	{ "application/vnd.osgi.dp", "dp" },
+	{ "application/vnd.osgi.subsystem", "esa" },
+	{ "application/vnd.palm", "pdb" },
+	{ "application/vnd.pawaafile", "paw" },
+	{ "application/vnd.pg.format", "str" },
+	{ "application/vnd.pg.osasli", "ei6" },
+	{ "application/vnd.picsel", "efif" },
+	{ "application/vnd.pmi.widget", "wg" },
+	{ "application/vnd.pocketlearn", "plf" },
+	{ "application/vnd.powerbuilder6", "pbd" },
+	{ "application/vnd.previewsystems.box", "box" },
+	{ "application/vnd.proteus.magazine", "mgz" },
+	{ "application/vnd.publishare-delta-tree", "qps" },
+	{ "application/vnd.pvi.ptid1", "ptid" },
+	{ "application/vnd.quark.quarkxpress", "qxd" },
+	{ "application/vnd.realvnc.bed", "bed" },
+	{ "application/vnd.recordare.musicxml", "mxl" },
+	{ "application/vnd.recordare.musicxml+xml", "musicxml" },
+	{ "application/vnd.rig.cryptonote", "cryptonote" },
+	{ "application/vnd.rim.cod", "cod" },
+	{ "application/vnd.rn-realmedia", "rm" },
+	{ "application/vnd.rn-realmedia-vbr", "rmvb" },
+	{ "application/vnd.route66.link66+xml", "link66" },
+	{ "application/vnd.sailingtracker.track", "st" },
+	{ "application/vnd.seemail", "see" },
+	{ "application/vnd.sema", "sema" },
+	{ "application/vnd.semd", "semd" },
+	{ "application/vnd.semf", "semf" },
+	{ "application/vnd.shana.informed.formdata", "ifm" },
+	{ "application/vnd.shana.informed.formtemplate", "itp" },
+	{ "application/vnd.shana.informed.interchange", "iif" },
+	{ "application/vnd.shana.informed.package", "ipk" },
+	{ "application/vnd.simtech-mindmapper", "twd" },
+	{ "application/vnd.smaf", "mmf" },
+	{ "application/vnd.smart.teacher", "teacher" },
+	{ "application/vnd.solent.sdkm+xml", "sdkm" },
+	{ "application/vnd.spotfire.dxp", "dxp" },
+	{ "application/vnd.spotfire.sfs", "sfs" },
+	{ "application/vnd.stardivision.calc", "sdc" },
+	{ "application/vnd.stardivision.draw", "sda" },
+	{ "application/vnd.stardivision.impress", "sdd" },
+	{ "application/vnd.stardivision.math", "smf" },
+	{ "application/vnd.stardivision.writer", "sdw" },
+	{ "application/vnd.stardivision.writer-global", "sgl" },
+	{ "application/vnd.stepmania.package", "smzip" },
+	{ "application/vnd.stepmania.stepchart", "sm" },
+	{ "application/vnd.sun.xml.calc", "sxc" },
+	{ "application/vnd.sun.xml.calc.template", "stc" },
+	{ "application/vnd.sun.xml.draw", "sxd" },
+	{ "application/vnd.sun.xml.draw.template", "std" },
+	{ "application/vnd.sun.xml.impress", "sxi" },
+	{ "application/vnd.sun.xml.impress.template", "sti" },
+	{ "application/vnd.sun.xml.math", "sxm" },
+	{ "application/vnd.sun.xml.writer", "sxw" },
+	{ "application/vnd.sun.xml.writer.global", "sxg" },
+	{ "application/vnd.sun.xml.writer.template", "stw" },
+	{ "application/vnd.sus-calendar", "sus" },
+	{ "application/vnd.svd", "svd" },
+	{ "application/vnd.symbian.install", "sis" },
+	{ "application/vnd.syncml+xml", "xsm" },
+	{ "application/vnd.syncml.dm+wbxml", "bdm" },
+	{ "application/vnd.syncml.dm+xml", "xdm" },
+	{ "application/vnd.tao.intent-module-archive", "tao" },
+	{ "application/vnd.tcpdump.pcap", "pcap" },
+	{ "application/vnd.tmobile-livetv", "tmo" },
+	{ "application/vnd.trid.tpt", "tpt" },
+	{ "application/vnd.triscape.mxs", "mxs" },
+	{ "application/vnd.trueapp", "tra" },
+	{ "application/vnd.ufdl", "ufd" },
+	{ "application/vnd.uiq.theme", "utz" },
+	{ "application/vnd.umajin", "umj" },
+	{ "application/vnd.unity", "unityweb" },
+	{ "application/vnd.uoml+xml", "uoml" },
+	{ "application/vnd.vcx", "vcx" },
+	{ "application/vnd.visio", "vsd" },
+	{ "application/vnd.visionary", "vis" },
+	{ "application/vnd.vsf", "vsf" },
+	{ "application/vnd.wap.wbxml", "wbxml" },
+	{ "application/vnd.wap.wmlc", "wmlc" },
+	{ "application/vnd.wap.wmlscriptc", "wmlsc" },
+	{ "application/vnd.webturbo", "wtb" },
+	{ "application/vnd.wolfram.player", "nbp" },
+	{ "application/vnd.wordperfect", "wpd" },
+	{ "application/vnd.wqd", "wqd" },
+	{ "application/vnd.wt.stf", "stf" },
+	{ "application/vnd.xara", "xar" },
+	{ "application/vnd.xfdl", "xfdl" },
+	{ "application/vnd.yamaha.hv-dic", "hvd" },
+	{ "application/vnd.yamaha.hv-script", "hvs" },
+	{ "application/vnd.yamaha.hv-voice", "hvp" },
+	{ "application/vnd.yamaha.openscoreformat", "osf" },
+	{ "application/vnd.yamaha.openscoreformat.osfpvg+xml", "osfpvg" },
+	{ "application/vnd.yamaha.smaf-audio", "saf" },
+	{ "application/vnd.yamaha.smaf-phrase", "spf" },
+	{ "application/vnd.yellowriver-custom-menu", "cmp" },
+	{ "application/vnd.zul", "zir" },
+	{ "application/vnd.zzazz.deck+xml", "zaz" },
+	{ "application/voicexml+xml", "vxml" },
+	{ "application/widget", "wgt" },
+	{ "application/winhlp", "hlp" },
+	{ "application/wsdl+xml", "wsdl" },
+	{ "application/wspolicy+xml", "wspolicy" },
+	{ "application/x-7z-compressed", "7z" },
+	{ "application/x-abiword", "abw" },
+	{ "application/x-ace-compressed", "ace" },
+	{ "application/x-apple-diskimage", "dmg" },
+	{ "application/x-authorware-bin", "aab" },
+	{ "application/x-authorware-map", "aam" },
+	{ "application/x-authorware-seg", "aas" },
+	{ "application/x-bcpio", "bcpio" },
+	{ "application/x-bittorrent", "torrent" },
+	{ "application/x-blorb", "blb" },
+	{ "application/x-bzip", "bz" },
+	{ "application/x-bzip2", "bz2" },
+	{ "application/x-cbr", "cbr" },
+	{ "application/x-cdlink", "vcd" },
+	{ "application/x-cfs-compressed", "cfs" },
+	{ "application/x-chat", "chat" },
+	{ "application/x-chess-pgn", "pgn" },
+	{ "application/x-conference", "nsc" },
+	{ "application/x-cpio", "cpio" },
+	{ "application/x-csh", "csh" },
+	{ "application/x-debian-package", "deb" },
+	{ "application/x-dgc-compressed", "dgc" },
+	{ "application/x-director", "dir" },
+	{ "application/x-doom", "wad" },
+	{ "application/x-dtbncx+xml", "ncx" },
+	{ "application/x-dtbook+xml", "dtb" },
+	{ "application/x-dtbresource+xml", "res" },
+	{ "application/x-dvi", "dvi" },
+	{ "application/x-envoy", "evy" },
+	{ "application/x-eva", "eva" },
+	{ "application/x-font-bdf", "bdf" },
+	{ "application/x-font-ghostscript", "gsf" },
+	{ "application/x-font-linux-psf", "psf" },
+	{ "application/x-font-otf", "otf" },
+	{ "application/x-font-pcf", "pcf" },
+	{ "application/x-font-snf", "snf" },
+	{ "application/x-font-ttf", "ttf" },
+	{ "application/x-font-type1", "pfa" },
+	{ "application/font-woff", "woff" },
+	{ "application/x-freearc", "arc" },
+	{ "application/x-futuresplash", "spl" },
+	{ "application/x-gca-compressed", "gca" },
+	{ "application/x-glulx", "ulx" },
+	{ "application/x-gnumeric", "gnumeric" },
+	{ "application/x-gramps-xml", "gramps" },
+	{ "application/x-gtar", "gtar" },
+	{ "application/x-hdf", "hdf" },
+	{ "application/x-install-instructions", "install" },
+	{ "application/x-iso9660-image", "iso" },
+	{ "application/x-java-jnlp-file", "jnlp" },
+	{ "application/x-latex", "latex" },
+	{ "application/x-lzh-compressed", "lzh" },
+	{ "application/x-mie", "mie" },
+	{ "application/x-mobipocket-ebook", "prc" },
+	{ "application/x-ms-application", "application" },
+	{ "application/x-ms-shortcut", "lnk" },
+	{ "application/x-ms-wmd", "wmd" },
+	{ "application/x-ms-wmz", "wmz" },
+	{ "application/x-ms-xbap", "xbap" },
+	{ "application/x-msaccess", "mdb" },
+	{ "application/x-msbinder", "obd" },
+	{ "application/x-mscardfile", "crd" },
+	{ "application/x-msclip", "clp" },
+	{ "application/x-msdownload", "exe" },
+	{ "application/x-msmediaview", "mvb" },
+	{ "application/x-msmetafile", "wmf" },
+	{ "application/x-msmoney", "mny" },
+	{ "application/x-mspublisher", "pub" },
+	{ "application/x-msschedule", "scd" },
+	{ "application/x-msterminal", "trm" },
+	{ "application/x-mswrite", "wri" },
+	{ "application/x-netcdf", "nc" },
+	{ "application/x-nzb", "nzb" },
+	{ "application/x-pkcs12", "p12" },
+	{ "application/x-pkcs7-certificates", "p7b" },
+	{ "application/x-pkcs7-certreqresp", "p7r" },
+	{ "application/x-rar-compressed", "rar" },
+	{ "application/x-research-info-systems", "ris" },
+	{ "application/x-sh", "sh" },
+	{ "application/x-shar", "shar" },
+	{ "application/x-shockwave-flash", "swf" },
+	{ "application/x-silverlight-app", "xap" },
+	{ "application/x-sql", "sql" },
+	{ "application/x-stuffit", "sit" },
+	{ "application/x-stuffitx", "sitx" },
+	{ "application/x-subrip", "srt" },
+	{ "application/x-sv4cpio", "sv4cpio" },
+	{ "application/x-sv4crc", "sv4crc" },
+	{ "application/x-t3vm-image", "t3" },
+	{ "application/x-tads", "gam" },
+	{ "application/x-tar", "tar" },
+	{ "application/x-tcl", "tcl" },
+	{ "application/x-tex", "tex" },
+	{ "application/x-tex-tfm", "tfm" },
+	{ "application/x-texinfo", "texinfo" },
+	{ "application/x-tgif", "obj" },
+	{ "application/x-ustar", "ustar" },
+	{ "application/x-wais-source", "src" },
+	{ "application/x-x509-ca-cert", "der" },
+	{ "application/x-xfig", "fig" },
+	{ "application/x-xliff+xml", "xlf" },
+	{ "application/x-xpinstall", "xpi" },
+	{ "application/x-xz", "xz" },
+	{ "application/x-zmachine", "z1" },
+	{ "application/xaml+xml", "xaml" },
+	{ "application/xcap-diff+xml", "xdf" },
+	{ "application/xenc+xml", "xenc" },
+	{ "application/xhtml+xml", "xhtml" },
+	{ "application/xml", "xml" },
+	{ "application/xml-dtd", "dtd" },
+	{ "application/xop+xml", "xop" },
+	{ "application/xproc+xml", "xpl" },
+	{ "application/xslt+xml", "xslt" },
+	{ "application/xspf+xml", "xspf" },
+	{ "application/xv+xml", "mxml" },
+	{ "application/yang", "yang" },
+	{ "application/yin+xml", "yin" },
+	{ "application/zip", "zip" },
+	{ "audio/adpcm", "adp" },
+	{ "audio/basic", "au" },
+	{ "audio/midi", "mid" },
+	{ "audio/mp4", "mp4a" },
+	{ "audio/mpeg", "mpga" },
+	{ "audio/ogg", "oga" },
+	{ "audio/s3m", "s3m" },
+	{ "audio/silk", "sil" },
+	{ "audio/vnd.dece.audio", "uva" },
+	{ "audio/vnd.digital-winds", "eol" },
+	{ "audio/vnd.dra", "dra" },
+	{ "audio/vnd.dts", "dts" },
+	{ "audio/vnd.dts.hd", "dtshd" },
+	{ "audio/vnd.lucent.voice", "lvp" },
+	{ "audio/vnd.ms-playready.media.pya", "pya" },
+	{ "audio/vnd.nuera.ecelp4800", "ecelp4800" },
+	{ "audio/vnd.nuera.ecelp7470", "ecelp7470" },
+	{ "audio/vnd.nuera.ecelp9600", "ecelp9600" },
+	{ "audio/vnd.rip", "rip" },
+	{ "audio/webm", "weba" },
+	{ "audio/x-aac", "aac" },
+	{ "audio/x-aiff", "aif" },
+	{ "audio/x-caf", "caf" },
+	{ "audio/x-flac", "flac" },
+	{ "audio/x-matroska", "mka" },
+	{ "audio/x-mpegurl", "m3u" },
+	{ "audio/x-ms-wax", "wax" },
+	{ "audio/x-ms-wma", "wma" },
+	{ "audio/x-pn-realaudio", "ram" },
+	{ "audio/x-pn-realaudio-plugin", "rmp" },
+	{ "audio/x-wav", "wav" },
+	{ "audio/xm", "xm" },
+	{ "chemical/x-cdx", "cdx" },
+	{ "chemical/x-cif", "cif" },
+	{ "chemical/x-cmdf", "cmdf" },
+	{ "chemical/x-cml", "cml" },
+	{ "chemical/x-csml", "csml" },
+	{ "chemical/x-xyz", "xyz" },
+	{ "image/bmp", "bmp" },
+	{ "image/cgm", "cgm" },
+	{ "image/g3fax", "g3" },
+	{ "image/gif", "gif" },
+	{ "image/ief", "ief" },
+	{ "image/jpg", "jpg" },
+	{ "image/jpeg", "jpeg" },
+	{ "image/ktx", "ktx" },
+	{ "image/png", "png" },
+	{ "image/prs.btif", "btif" },
+	{ "image/sgi", "sgi" },
+	{ "image/svg+xml", "svg" },
+	{ "image/tiff", "tiff" },
+	{ "image/vnd.adobe.photoshop", "psd" },
+	{ "image/vnd.dece.graphic", "uvi" },
+	{ "image/vnd.dvb.subtitle", "sub" },
+	{ "image/vnd.djvu", "djvu" },
+	{ "image/vnd.dwg", "dwg" },
+	{ "image/vnd.dxf", "dxf" },
+	{ "image/vnd.fastbidsheet", "fbs" },
+	{ "image/vnd.fpx", "fpx" },
+	{ "image/vnd.fst", "fst" },
+	{ "image/vnd.fujixerox.edmics-mmr", "mmr" },
+	{ "image/vnd.fujixerox.edmics-rlc", "rlc" },
+	{ "image/vnd.ms-modi", "mdi" },
+	{ "image/vnd.ms-photo", "wdp" },
+	{ "image/vnd.net-fpx", "npx" },
+	{ "image/vnd.wap.wbmp", "wbmp" },
+	{ "image/vnd.xiff", "xif" },
+	{ "image/webp", "webp" },
+	{ "image/x-3ds", "3ds" },
+	{ "image/x-cmu-raster", "ras" },
+	{ "image/x-cmx", "cmx" },
+	{ "image/x-freehand", "fh" },
+	{ "image/x-icon", "ico" },
+	{ "image/x-mrsid-image", "sid" },
+	{ "image/x-pcx", "pcx" },
+	{ "image/x-pict", "pic" },
+	{ "image/x-portable-anymap", "pnm" },
+	{ "image/x-portable-bitmap", "pbm" },
+	{ "image/x-portable-graymap", "pgm" },
+	{ "image/x-portable-pixmap", "ppm" },
+	{ "image/x-rgb", "rgb" },
+	{ "image/x-tga", "tga" },
+	{ "image/x-xbitmap", "xbm" },
+	{ "image/x-xpixmap", "xpm" },
+	{ "image/x-xwindowdump", "xwd" },
+	{ "message/rfc822", "eml" },
+	{ "model/iges", "igs" },
+	{ "model/mesh", "msh" },
+	{ "model/vnd.collada+xml", "dae" },
+	{ "model/vnd.dwf", "dwf" },
+	{ "model/vnd.gdl", "gdl" },
+	{ "model/vnd.gtw", "gtw" },
+	{ "model/vnd.mts", "mts" },
+	{ "model/vnd.vtu", "vtu" },
+	{ "model/vrml", "wrl" },
+	{ "model/x3d+binary", "x3db" },
+	{ "model/x3d+vrml", "x3dv" },
+	{ "model/x3d+xml", "x3d" },
+	{ "text/cache-manifest", "appcache" },
+	{ "text/calendar", "ics" },
+	{ "text/css", "css" },
+	{ "text/csv", "csv" },
+	{ "text/html", "html" },
+	{ "text/n3", "n3" },
+	{ "text/plain", "txt" },
+	{ "text/prs.lines.tag", "dsc" },
+	{ "text/richtext", "rtx" },
+	{ "text/sgml", "sgml" },
+	{ "text/tab-separated-values", "tsv" },
+	{ "text/troff", "t" },
+	{ "text/turtle", "ttl" },
+	{ "text/uri-list", "uri" },
+	{ "text/vcard", "vcard" },
+	{ "text/vnd.curl", "curl" },
+	{ "text/vnd.curl.dcurl", "dcurl" },
+	{ "text/vnd.curl.scurl", "scurl" },
+	{ "text/vnd.curl.mcurl", "mcurl" },
+	{ "text/vnd.dvb.subtitle", "sub" },
+	{ "text/vnd.fly", "fly" },
+	{ "text/vnd.fmi.flexstor", "flx" },
+	{ "text/vnd.graphviz", "gv" },
+	{ "text/vnd.in3d.3dml", "3dml" },
+	{ "text/vnd.in3d.spot", "spot" },
+	{ "text/vnd.sun.j2me.app-descriptor", "jad" },
+	{ "text/vnd.wap.wml", "wml" },
+	{ "text/vnd.wap.wmlscript", "wmls" },
+	{ "text/x-asm", "s" },
+	{ "text/x-c", "c" },
+	{ "text/x-fortran", "f" },
+	{ "text/x-java-source", "java" },
+	{ "text/x-opml", "opml" },
+	{ "text/x-pascal", "p" },
+	{ "text/x-nfo", "nfo" },
+	{ "text/x-setext", "etx" },
+	{ "text/x-sfv", "sfv" },
+	{ "text/x-uuencode", "uu" },
+	{ "text/x-vcalendar", "vcs" },
+	{ "text/x-vcard", "vcf" },
+	{ "text/xml", "xml" },
+	{ "video/3gpp", "3gp" },
+	{ "video/3gpp2", "3g2" },
+	{ "video/h261", "h261" },
+	{ "video/h263", "h263" },
+	{ "video/h264", "h264" },
+	{ "video/jpeg", "jpgv" },
+	{ "video/jpm", "jpm" },
+	{ "video/mj2", "mj2" },
+	{ "video/mp4", "mp4" },
+	{ "video/mpeg", "mpeg" },
+	{ "video/ogg", "ogv" },
+	{ "video/quicktime", "qt" },
+	{ "video/vnd.dece.hd", "uvh" },
+	{ "video/vnd.dece.mobile", "uvm" },
+	{ "video/vnd.dece.pd", "uvp" },
+	{ "video/vnd.dece.sd", "uvs" },
+	{ "video/vnd.dece.video", "uvv" },
+	{ "video/vnd.dvb.file", "dvb" },
+	{ "video/vnd.fvt", "fvt" },
+	{ "video/vnd.mpegurl", "mxu" },
+	{ "video/vnd.ms-playready.media.pyv", "pyv" },
+	{ "video/vnd.uvvu.mp4", "uvu" },
+	{ "video/vnd.vivo", "viv" },
+	{ "video/webm", "webm" },
+	{ "video/x-f4v", "f4v" },
+	{ "video/x-fli", "fli" },
+	{ "video/x-flv", "flv" },
+	{ "video/x-m4v", "m4v" },
+	{ "video/x-matroska", "mkv" },
+	{ "video/x-mng", "mng" },
+	{ "video/x-ms-asf", "asf" },
+	{ "video/x-ms-vob", "vob" },
+	{ "video/x-ms-wm", "wm" },
+	{ "video/x-ms-wmv", "wmv" },
+	{ "video/x-ms-wmx", "wmx" },
+	{ "video/x-ms-wvx", "wvx" },
+	{ "video/x-msvideo", "avi" },
+	{ "video/x-sgi-movie", "movie" },
+	{ "video/x-smv", "smv" },
+	{ "x-conference/x-cooltalk", "ice" }
+};
+
+/**
+* Obtain default file extension for a give MIME type
+*
+* @param mimeType a MIME type (lowercase string), e.g. "image/png"
+* @param extension a buffer in which to store the file extension; the default value is "txt" if no extension is found
+* @param length the size of the buffer extension
+* @return true if a file extension is found for the given MIME type, otherwise false
+*/
+static bool getFileExtension(const char* mimeType, char* extension, size_t length) {
+
+	bool hasExt = false;
+	strncpy(extension, "txt", length);
+	
+	if (mimeType != NULL) { 	
+		for (int i = 0; i < NUM_MIME_TYPES; i++) {					
+			if 	(strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
+				strncpy(extension, MIME[i][M_Extension], length);
+				hasExt = true;
+				break;				
+			}		
+		}
+		if (hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
+			strncpy(extension, strstr(mimeType, "/") + 1, length);
+		}	
+	}	
+	return hasExt;
+}
+
+/**
+* Obtain default file extension for a give MIME type
+*
+* @param mimeType a MIME type (lowercase string), e.g. "image/png"
+* @param hasExt the value of this pointer is set to true if a default file extension is found, otherwise false
+* @return a map with name "extension" and value set to file extension, e.g. "png"; if not found the default value is "txt" 
+*/
+static map* getFileExtensionMap(const char* mimeType, bool* hasExt) {
+
+	map* ext = createMap("extension", "txt");
+	*hasExt = false;
+	
+	if (mimeType != NULL) { 	
+		for (int i = 0; i < NUM_MIME_TYPES; i++) {			
+			if 	(strncmp(mimeType, MIME[i][M_Type], strlen(MIME[i][M_Type])) == 0) {
+				ext->value = zStrdup(MIME[i][M_Extension]);
+				*hasExt = true;
+				break;				
+			}		
+		}
+		if (*hasExt == false && strncmp(mimeType, "image/", 6) == 0) {
+			ext->value = zStrdup(strstr(mimeType, "/") + 1);
+		}			
+	}	
+	return ext;
+}
Index: trunk/zoo-project/zoo-kernel/service.h
===================================================================
--- trunk/zoo-project/zoo-kernel/service.h	(revision 600)
+++ trunk/zoo-project/zoo-kernel/service.h	(revision 601)
@@ -252,5 +252,5 @@
     }
   }
-
+  
   /**
    * Dump a maps on stderr, see dumpMap().
@@ -283,5 +283,5 @@
     fclose(file);
   }
-
+  
   /**
    * Create a new map
Index: trunk/zoo-project/zoo-kernel/service_internal.c
===================================================================
--- trunk/zoo-project/zoo-kernel/service_internal.c	(revision 600)
+++ trunk/zoo-project/zoo-kernel/service_internal.c	(revision 601)
@@ -42,4 +42,6 @@
 
 #define ERROR_MSG_MAX_LENGTH 1024
+
+#include "mimetypes.h"
 
 /**
@@ -2184,4 +2186,5 @@
  */
 void printIOType(xmlDocPtr doc,xmlNodePtr nc,xmlNsPtr ns_wps,xmlNsPtr ns_ows,xmlNsPtr ns_xlink,elements* e,maps* m,const char* type){
+
   xmlNodePtr nc1,nc2,nc3;
   nc1=xmlNewNode(ns_wps, BAD_CAST type);
@@ -2191,8 +2194,5 @@
   else
     tmp=m->content;
-#ifdef DEBUG
-  dumpMap(tmp);
-  dumpElements(e);
-#endif
+
   nc2=xmlNewNode(ns_ows, BAD_CAST "Identifier");
   if(e!=NULL)
@@ -2200,4 +2200,5 @@
   else
     nc3=xmlNewText(BAD_CAST m->name);
+
   xmlAddChild(nc2,nc3);
   xmlAddChild(nc1,nc2);
@@ -2219,4 +2220,5 @@
   else
     tmp=getMap(m->content,"Abstract");
+
   if(tmp!=NULL){
     nc2=xmlNewNode(ns_ows, BAD_CAST tmp->name);
@@ -2230,7 +2232,4 @@
    * IO type Reference or full Data ?
    */
-#ifdef DEBUG
-  fprintf(stderr,"FORMAT %s %s\n",e->format,e->format);
-#endif
   map *tmpMap=getMap(m->content,"Reference");
   if(tmpMap==NULL){
@@ -2238,146 +2237,135 @@
     if(e!=NULL){
       if(strncasecmp(e->format,"LiteralOutput",strlen(e->format))==0)
-	nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
+         nc3=xmlNewNode(ns_wps, BAD_CAST "LiteralData");
       else
-	if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
-	  nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
-	else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
-	  nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
-	else
-	  nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
-    }
-    else{
+        if(strncasecmp(e->format,"ComplexOutput",strlen(e->format))==0)
+		   nc3=xmlNewNode(ns_wps, BAD_CAST "ComplexData");
+	  else if(strncasecmp(e->format,"BoundingBoxOutput",strlen(e->format))==0)
+	    nc3=xmlNewNode(ns_wps, BAD_CAST "BoundingBoxData");
+	  else
+	    nc3=xmlNewNode(ns_wps, BAD_CAST e->format);
+    }
+    else {
       map* tmpV=getMapFromMaps(m,"format","value");
       if(tmpV!=NULL)
-	nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
+	    nc3=xmlNewNode(ns_wps, BAD_CAST tmpV->value);
       else
-	nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
+	    nc3=xmlNewNode(ns_wps, BAD_CAST "LitteralData");
     } 
     tmp=m->content;
-#ifdef USE_MS
-    map* testMap=getMap(tmp,"requestedMimeType");
-#endif
+
     while(tmp!=NULL){
       if(strcasecmp(tmp->name,"mimeType")==0 ||
-	 strcasecmp(tmp->name,"encoding")==0 ||
-	 strcasecmp(tmp->name,"schema")==0 ||
-	 strcasecmp(tmp->name,"datatype")==0 ||
-	 strcasecmp(tmp->name,"uom")==0){
-#ifdef USE_MS
-	if(testMap==NULL || (testMap!=NULL && strncasecmp(testMap->value,"text/xml",8)==0)){
-#endif
-	  xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
-#ifdef USE_MS
-	}
-	else
-	  if(strcasecmp(tmp->name,"mimeType")==0){
-	    if(testMap!=NULL)
-	      xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
-	    else 
-	      xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
-	  }
-#endif
+	     strcasecmp(tmp->name,"encoding")==0 ||
+	     strcasecmp(tmp->name,"schema")==0 ||
+	     strcasecmp(tmp->name,"datatype")==0 ||
+	     strcasecmp(tmp->name,"uom")==0) {
+
+	    xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
       }
       tmp=tmp->next;
       xmlAddChild(nc2,nc3);
     }
-    if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0){
+    if(e!=NULL && e->format!=NULL && strcasecmp(e->format,"BoundingBoxData")==0) {
       map* bb=getMap(m->content,"value");
-      if(bb!=NULL){
-	map* tmpRes=parseBoundingBox(bb->value);
-	printBoundingBox(ns_ows,nc3,tmpRes);
-	freeMap(&tmpRes);
-	free(tmpRes);
-      }
-    }else{
+      if(bb!=NULL) {
+	    map* tmpRes=parseBoundingBox(bb->value);
+	    printBoundingBox(ns_ows,nc3,tmpRes);
+	    freeMap(&tmpRes);
+	    free(tmpRes);
+      }
+    }
+	else {
       if(e!=NULL)
-	tmp=getMap(e->defaults->content,"mimeType");
+	    tmp=getMap(e->defaults->content,"mimeType");
       else
-	tmp=NULL;
-#ifdef USE_MS
-      /**
-       * In case of OGC WebServices output use, as the data was requested
-       * with asReference=false we have to download the resulting OWS request
-       * stored in the Reference map value.
-       */
-      map* testMap=getMap(m->content,"requestedMimeType");
-      if(testMap!=NULL){
-	HINTERNET hInternet;
-	char* tmpValue;
-	size_t dwRead;
-	hInternet=InternetOpen(
-#ifndef WIN32
-			       (LPCTSTR)
-#endif
-			       "ZooWPSClient\0",
-			       INTERNET_OPEN_TYPE_PRECONFIG,
-			       NULL,NULL, 0);
-	testMap=getMap(m->content,"Reference");
-	loadRemoteFile(&m,&m->content,&hInternet,testMap->value);
-	processDownloads(&hInternet);
-	tmpValue=(char*)malloc((hInternet.ihandle[0].nDataLen+1)*sizeof(char));
-	InternetReadFile(hInternet.ihandle[0],(LPVOID)tmpValue,hInternet.ihandle[0].nDataLen,&dwRead);
-	InternetCloseHandle(&hInternet);
-      }
-#endif
-      map* tmp1=getMap(m->content,"encoding");
-      map* tmp2=getMap(m->content,"mimeType");
-      map* tmp3=getMap(m->content,"value");
-      int hasValue=1;
-      if(tmp3==NULL){
-	tmp3=createMap("value","");
-	hasValue=-1;
-      }
-      if((tmp1!=NULL && strncmp(tmp1->value,"base64",6)==0)
-	 || (tmp2!=NULL && (strncmp(tmp2->value,"image/",6)==0 ||
-			    (strncmp(tmp2->value,"application/",12)==0 &&
-			     strncmp(tmp2->value,"application/json",16)!=0&&
-			     strncmp(tmp2->value,"application/x-javascript",24)!=0&&
-			     strncmp(tmp2->value,"application/vnd.google-earth.kml",32)!=0))
-	     )) {
-	map* rs=getMap(m->content,"size");
-	bool isSized=true;
-	if(rs==NULL){
-	  char tmp1[1024];
-	  sprintf(tmp1,"%ld",strlen(tmp3->value));
-	  rs=createMap("size",tmp1);
-	  isSized=false;
-	}
-
-	xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));
-	if(tmp1==NULL || (tmp1!=NULL && strncmp(tmp1->value,"base64",6)!=0))
-	  xmlNewProp(nc3,BAD_CAST "encoding",BAD_CAST "base64");
-	if(!isSized){
-	  freeMap(&rs);
-	  free(rs);
-	}
-      }
-      else if(tmp2!=NULL){
-	if(strncmp(tmp2->value,"text/js",7)==0 ||
-	   strncmp(tmp2->value,"application/json",16)==0)
-	  xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
-	else{
-	  if(strncmp(tmp2->value,"text/xml",8)==0 ||
-	     strncmp(tmp2->value,"application/vnd.google-earth.kml",32)==0){
-	    int li=zooXmlAddDoc(tmp3->value);
-	    xmlDocPtr doc = iDocs[li];
-	    xmlNodePtr ir = xmlDocGetRootElement(doc);
-	    xmlAddChild(nc3,ir);
-	  }
-	  else
+	    tmp=NULL;
+	
+        map* tmp1=getMap(m->content,"encoding");
+        map* tmp2=getMap(m->content,"mimeType");
+        map* tmp3=getMap(m->content,"value");
+        int hasValue=1;
+        if(tmp3==NULL){
+	      tmp3=createMap("value","");
+	      hasValue=-1;
+        }
+
+       if( ( tmp1 != NULL && strncmp(tmp1->value,"base64",6) == 0 )  // if encoding is base64
+	        || 	                                                     // or if 
+	        ( tmp2 != NULL && ( strstr(tmp2->value,"text") == NULL //  mime type is not text 
+	                            &&                                   //  nor 
+							    strstr(tmp2->value,"xml") == NULL  //  xml
+								&&                                          // nor
+								strstr(tmp2->value,"javascript") == NULL  // javascript
+								&&
+								strstr(tmp2->value,"json") == NULL
+								&&
+								strstr(tmp2->value,"ecmascript") == NULL
+								&&
+								// include for backwards compatibility,
+								// although correct mime type is ...kml+xml:
+								strstr(tmp2->value,"google-earth.kml") == NULL								
+							  )
+	        )
+		  ) { 	                                                   // then	
+	      map* rs=getMap(m->content,"size");                       // obtain size
+	      bool isSized=true;
+	      if(rs==NULL){
+	        char tmp1[1024];
+	        sprintf(tmp1,"%ld",strlen(tmp3->value));
+	        rs=createMap("size",tmp1);
+	        isSized=false;
+	      }
+
+	    xmlAddChild(nc3,xmlNewText(BAD_CAST base64(tmp3->value, atoi(rs->value))));  // base 64 encode in XML
+		
+	    if(tmp1==NULL || (tmp1!=NULL && strncmp(tmp1->value,"base64",6)!=0)) {
+	       xmlAttrPtr ap = xmlHasProp(nc3, BAD_CAST "encoding");
+	       if (ap != NULL) {
+	          xmlRemoveProp(ap);
+	       }			
+	       xmlNewProp(nc3,BAD_CAST "encoding",BAD_CAST "base64");
+		}
+		
+ 	    if(!isSized){
+	      freeMap(&rs);
+	      free(rs);
+	    }
+      }
+      else if (tmp2!=NULL) {                                 // else (text-based format) 
+	    if(strstr(tmp2->value, "javascript") != NULL ||      //    if javascript put code in CDATA block 
+	       strstr(tmp2->value, "json") != NULL ||            //    (will not be parsed by XML reader) 
+	       strstr(tmp2->value, "ecmascript") != NULL
+		  ) {
+	       xmlAddChild(nc3,xmlNewCDataBlock(doc,BAD_CAST tmp3->value,strlen(tmp3->value)));
+		}   
+	    else {                                                     // else
+	       if (strstr(tmp2->value, "xml") != NULL ||                 // if XML-based format
+			   // include for backwards compatibility,
+			   // although correct mime type is ...kml+xml:		   
+	           strstr(tmp2->value, "google-earth.kml") != NULL
+			  ) { 
+			  
+	          int li=zooXmlAddDoc(tmp3->value);
+	          xmlDocPtr doc = iDocs[li];
+	          xmlNodePtr ir = xmlDocGetRootElement(doc);
+	          xmlAddChild(nc3,ir);
+	       }
+	       else                                                     // else	
+	          xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));    //   add text node
+	    }
+	    xmlAddChild(nc2,nc3);
+      }
+      else {
 	    xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
-	}
-	xmlAddChild(nc2,nc3);
-      }
-      else{
-	xmlAddChild(nc3,xmlNewText(BAD_CAST tmp3->value));
-      }
-      if(hasValue<0){
-	freeMap(&tmp3);
-	free(tmp3);
-      }
-    }
-  }
-  else{
+      }
+	  
+      if(hasValue<0) {
+	    freeMap(&tmp3);
+	    free(tmp3);
+      }
+    }
+  }
+  else { // Reference
     tmpMap=getMap(m->content,"Reference");
     nc3=nc2=xmlNewNode(ns_wps, BAD_CAST "Reference");
@@ -2386,25 +2374,17 @@
     else
       xmlNewNsProp(nc3,ns_xlink,BAD_CAST "href",BAD_CAST tmpMap->value);
-    tmp=m->content;
-#ifdef USE_MS
-    map* testMap=getMap(tmp,"requestedMimeType");
-#endif
-    while(tmp!=NULL){
+    
+	tmp=m->content;
+    while(tmp!=NULL) {
       if(strcasecmp(tmp->name,"mimeType")==0 ||
-	 strcasecmp(tmp->name,"encoding")==0 ||
-	 strcasecmp(tmp->name,"schema")==0 ||
-	 strcasecmp(tmp->name,"datatype")==0 ||
-	 strcasecmp(tmp->name,"uom")==0){
-#ifdef USE_MS
-	if(testMap!=NULL  && strncasecmp(testMap->value,"text/xml",8)!=0){
-	  if(strcasecmp(tmp->name,"mimeType")==0)
-	    xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST testMap->value);
-	}
-	else
-#endif
-	  if(strcasecmp(tmp->name,"datatype")==0)
-	    xmlNewProp(nc3,BAD_CAST "mimeType",BAD_CAST "text/plain");
-	  else
-	    xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
+	     strcasecmp(tmp->name,"encoding")==0 ||
+	     strcasecmp(tmp->name,"schema")==0 ||
+	     strcasecmp(tmp->name,"datatype")==0 ||
+	     strcasecmp(tmp->name,"uom")==0){
+
+	    if(strcasecmp(tmp->name,"datatype")==0)
+	      xmlNewProp(nc3,BAD_CAST "mimeType",BAD_CAST "text/plain");
+	    else
+	      xmlNewProp(nc3,BAD_CAST tmp->name,BAD_CAST tmp->value);
       }
       tmp=tmp->next;
@@ -2414,5 +2394,4 @@
   xmlAddChild(nc1,nc2);
   xmlAddChild(nc,nc1);
-
 }
 
@@ -2808,37 +2787,23 @@
 	    map *ext=getMap(tmpI->content,"extension");
 	    char *file_path;
-	    bool hasExt=true;
-	    if(ext==NULL){
-	      // We can fallback to a default list of supported formats using
-	      // mimeType information if present here. Maybe we can add more formats
-	      // here.
-	      // If mimeType was not found, we then set txt as the default extension
+		char file_ext[32];
+
+	    if( ext != NULL && ext->value != NULL) {
+			strncpy(file_ext, ext->value, 32);
+		}
+		else {
+	      // Obtain default file extension (see mimetypes.h).	      
+	      // If the MIME type is not recognized, txt is used as the default extension
 	      map* mtype=getMap(tmpI->content,"mimeType");
-	      if(mtype!=NULL) {
-		if(strncasecmp(mtype->value,"text/xml",8)==0)
-		  ext=createMap("extension","xml");
-		else if(strncasecmp(mtype->value,"application/zip",15)==0)
-		  ext=createMap("extension","zip");
-		else if(strncasecmp(mtype->value,"application/json",16)==0)
-		  ext=createMap("extension","js");
-		else if(strncmp(mtype->value,"application/vnd.google-earth.kml",32)==0)
-		  ext=createMap("extension","kml");
-		else if(strncmp(mtype->value,"image/",6)==0)
-		  ext=createMap("extension",strstr(mtype->value,"/")+1);
-	    else if(strcasecmp(mtype->value,"text/html")==0)
-	      ext=createMap("extension","html");	  
-		else
-		  ext=createMap("extension","txt");
-	      }
-	      else
-		ext=createMap("extension","txt");
-	      hasExt=false;
+		  getFileExtension(mtype != NULL ? mtype->value : NULL, file_ext, 32);
 	    }
-	    file_name=(char*)malloc((strlen(s->name)+strlen(ext->value)+strlen(tmpI->name)+1024)*sizeof(char));
-	    int cpid0=cpid+time(NULL);
-	    sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,ext->value);
+		
+		file_name=(char*)malloc((strlen(s->name)+strlen(file_ext)+strlen(tmpI->name)+1024)*sizeof(char));
+	    int cpid0=cpid+time(NULL);	    
+		sprintf(file_name,"%s_%s_%i.%s",s->name,tmpI->name,cpid0,file_ext);
 	    file_path=(char*)malloc((strlen(tmp1->value)+strlen(file_name)+2)*sizeof(char));
 	    sprintf(file_path,"%s/%s",tmp1->value,file_name);
-	    FILE *ofile=fopen(file_path,"wb");
+	    
+		FILE *ofile=fopen(file_path,"wb");
 	    if(ofile==NULL){
 	      char tmpMsg[1024];
@@ -2850,8 +2815,5 @@
 	    }
 	    free(file_path);
-	    if(!hasExt){
-	      freeMap(&ext);
-	      free(ext);
-	    }
+
 	    toto=getMap(tmpI->content,"value");
 	    if(strcasecmp(format,"BoundingBoxData")!=0){
Index: trunk/zoo-project/zoo-kernel/zoo_loader.c
===================================================================
--- trunk/zoo-project/zoo-kernel/zoo_loader.c	(revision 600)
+++ trunk/zoo-project/zoo-kernel/zoo_loader.c	(revision 601)
@@ -84,5 +84,4 @@
   fflush(stderr);
 #endif
-
   
   char *strQuery=NULL;
@@ -134,13 +133,14 @@
 	  char *ivalue=new char[cgiContentLength];
 	  cgiFormStringNoNewlines(*arrayStep, ivalue, cgiContentLength);
-	  char* tmpValueFinal=(char*) malloc((strlen(*arrayStep)+strlen(ivalue)+1)*sizeof(char));
+	  char* tmpValueFinal=(char*) malloc((strlen(*arrayStep)+strlen(ivalue)+2)*sizeof(char));	
 	  sprintf(tmpValueFinal,"%s=%s",*arrayStep,ivalue);
-	  if(strlen(buffer)==0){
+
+	  if(strlen(buffer)==0){		
 	    sprintf(buffer,"%s",tmpValueFinal);
-	  }else{
+	  }else{		
 	    char *tmp=zStrdup(buffer);
 	    sprintf(buffer,"%s&%s",tmp,tmpValueFinal);
 	    free(tmp);
-	  }
+	  }	  
 	  free(tmpValueFinal);
 #ifdef DEBUG
@@ -149,5 +149,5 @@
 	  delete[]ivalue;
 	  arrayStep++;
-	}
+	}	
 	if(tmpMap!=NULL)
 	  addToMap(tmpMap,"request",buffer);
@@ -156,5 +156,5 @@
       }
       delete[]buffer;
-    }
+    }	
   }
   else{
@@ -344,5 +344,5 @@
           value=zStrdup(token1);
         token1=strtok_r(NULL,"=",&saveptr1);
-      }
+      }	  
       //addToMap(tmpMap,name,value);
 	  /* knut: strtok(_r) ignores delimiter bytes at start and end of string; 
Index: trunk/zoo-project/zoo-kernel/zoo_service_loader.c
===================================================================
--- trunk/zoo-project/zoo-kernel/zoo_service_loader.c	(revision 600)
+++ trunk/zoo-project/zoo-kernel/zoo_service_loader.c	(revision 601)
@@ -1867,4 +1867,5 @@
       fflush (stderr);
 #endif
+
     /**
      * Parse every Input in DataInputs node.
@@ -2334,6 +2335,7 @@
 
                           map *test = getMap (tmpmaps->content, "encoding");
+
                           if (test == NULL)
-                            {
+                            { 
                               if (tmpmaps->content != NULL)
                                 addToMap (tmpmaps->content, "encoding",
@@ -2346,5 +2348,5 @@
 
                           if (strcasecmp (test->value, "base64") != 0)
-                            {
+                            { 
                               xmlChar *mv = xmlNodeListGetString (doc,
                                                                   cur4->
@@ -2381,5 +2383,5 @@
                                                 size);
                                       xmlFreeDoc (doc1);
-                                    }
+                                    }									
                                 }
                               if (mv != NULL)
@@ -2576,293 +2578,166 @@
         }
       else
-        for (int k = 0; k < tmps->nodeNr; k++)
-          {
-            //else
-            addToMap (request_inputs, "ResponseDocument", "");
-            maps *tmpmaps = NULL;
-            xmlNodePtr cur = tmps->nodeTab[k];
-            if (cur->type == XML_ELEMENT_NODE)
-              {
-          /**
-	   * A specific responseDocument node.
-	   */
-                if (tmpmaps == NULL)
-                  {
-                    tmpmaps = (maps *) malloc (MAPS_SIZE);
-                    if (tmpmaps == NULL)
-                      {
-                        return errorException (m,
-                                               _
-                                               ("Unable to allocate memory."),
-                                               "InternalError", NULL);
-                      }
-                    tmpmaps->name = zStrdup ("unknownIdentifier");
-                    tmpmaps->content = NULL;
-                    tmpmaps->next = NULL;
-                  }
-          /**
-	   * Get every attribute: storeExecuteResponse, lineage, status
-	   */
-                const char *ress[3] =
-                  { "storeExecuteResponse", "lineage", "status" };
-                xmlChar *val;
-                for (int l = 0; l < 3; l++)
-                  {
-#ifdef DEBUG
-                    fprintf (stderr, "*** %s ***\t", ress[l]);
-#endif
-                    val = xmlGetProp (cur, BAD_CAST ress[l]);
-                    if (val != NULL && strlen ((char *) val) > 0)
-                      {
-                        if (tmpmaps->content != NULL)
-                          addToMap (tmpmaps->content, ress[l], (char *) val);
-                        else
-                          tmpmaps->content =
-                            createMap (ress[l], (char *) val);
-                        addToMap (request_inputs, ress[l], (char *) val);
-                      }
-#ifdef DEBUG
-                    fprintf (stderr, "%s\n", val);
-#endif
-                    xmlFree (val);
-                  }
-                xmlNodePtr cur1 = cur->children;
-                while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
-                  cur1 = cur1->next;
-                int cur1cnt = 0;
-                while (cur1)
-                  {
-            /**
-	     * Indentifier
-	     */
-                    if (xmlStrncasecmp
-                        (cur1->name, BAD_CAST "Identifier",
-                         xmlStrlen (cur1->name)) == 0)
-                      {
-                        xmlChar *val =
-                          xmlNodeListGetString (doc, cur1->xmlChildrenNode,
-                                                1);
-                        if (tmpmaps == NULL)
-                          {
-                            tmpmaps = (maps *) malloc (MAPS_SIZE);
-                            if (tmpmaps == NULL)
-                              {
-                                return errorException (m,
-                                                       _
-                                                       ("Unable to allocate memory."),
-                                                       "InternalError", NULL);
-                              }
-                            tmpmaps->name = zStrdup ((char *) val);
-                            tmpmaps->content = NULL;
-                            tmpmaps->next = NULL;
-                          }
-                        else
-                          {
-                            free (tmpmaps->name);
-                            tmpmaps->name = zStrdup ((char *) val);
-                          }
-                        if (asRaw == true)
-                          addToMap (request_inputs, "RawDataOutput",
-                                    (char *) val);
-                        else
-                          {
-                            if (cur1cnt == 0)
-                              addToMap (request_inputs, "ResponseDocument",
-                                        (char *) val);
-                            else
-                              {
-                                map *tt =
-                                  getMap (request_inputs, "ResponseDocument");
-                                char *tmp = zStrdup (tt->value);
-                                free (tt->value);
-                                tt->value =
-                                  (char *)
-                                  malloc ((strlen (tmp) +
-                                           strlen ((char *) val) +
-                                           1) * sizeof (char));
-                                sprintf (tt->value, "%s;%s", tmp,
-                                         (char *) val);
-                                free (tmp);
-                              }
-                          }
-                        cur1cnt += 1;
-                        xmlFree (val);
-                      }
-            /**
-	     * Title, Asbtract
-	     */
-                    else
-                      if (xmlStrncasecmp
-                          (cur1->name, BAD_CAST "Title",
-                           xmlStrlen (cur1->name)) == 0
-                          || xmlStrncasecmp (cur1->name, BAD_CAST "Abstract",
-                                             xmlStrlen (cur1->name)) == 0)
-                      {
-                        xmlChar *val =
-                          xmlNodeListGetString (doc, cur1->xmlChildrenNode,
-                                                1);
-                        if (tmpmaps == NULL)
-                          {
-                            tmpmaps = (maps *) malloc (MAPS_SIZE);
-                            if (tmpmaps == NULL)
-                              {
-                                return errorException (m,
-                                                       _
-                                                       ("Unable to allocate memory."),
-                                                       "InternalError", NULL);
-                              }
-                            tmpmaps->name = zStrdup ("missingIndetifier");
-                            tmpmaps->content =
-                              createMap ((char *) cur1->name, (char *) val);
-                            tmpmaps->next = NULL;
-                          }
-                        else
-                          {
-                            if (tmpmaps->content != NULL)
-                              addToMap (tmpmaps->content, (char *) cur1->name,
-                                        (char *) val);
-                            else
-                              tmpmaps->content =
-                                createMap ((char *) cur1->name, (char *) val);
-                          }
-                        xmlFree (val);
-                      }
-                    else
-                      if (xmlStrncasecmp
-                          (cur1->name, BAD_CAST "Output",
-                           xmlStrlen (cur1->name)) == 0)
-                      {
-              /**
-	       * Get every attribute from an Output node
-	       * mimeType, encoding, schema, uom, asReference
-	       */
-                        const char *outs[5] =
-                          { "mimeType", "encoding", "schema", "uom",
-                          "asReference"
-                        };
-                        for (int l = 0; l < 5; l++)
-                          {
-#ifdef DEBUG
-                            fprintf (stderr, "*** %s ***\t", outs[l]);
-#endif
-                            xmlChar *val =
-                              xmlGetProp (cur1, BAD_CAST outs[l]);
-                            if (val != NULL && strlen ((char *) val) > 0)
-                              {
-                                if (tmpmaps->content != NULL)
-                                  addToMap (tmpmaps->content, outs[l],
-                                            (char *) val);
-                                else
-                                  tmpmaps->content =
-                                    createMap (outs[l], (char *) val);
-                              }
-#ifdef DEBUG
-                            fprintf (stderr, "%s\n", val);
-#endif
-                            xmlFree (val);
-                          }
-                        xmlNodePtr cur2 = cur1->children;
-                        while (cur2 != NULL && cur2->type != XML_ELEMENT_NODE)
-                          cur2 = cur2->next;
-                        while (cur2)
-                          {
-                /**
-		 * Indentifier
+	  {
+		addToMap (request_inputs, "ResponseDocument", "");
+			
+		xmlNodePtr cur = tmps->nodeTab[0]; // only one ResponseDocument node
+		if (cur->type == XML_ELEMENT_NODE) {
+		/**
+		 * Get every attribute: storeExecuteResponse, lineage, status
 		 */
-                            if (xmlStrncasecmp
-                                (cur2->name, BAD_CAST "Identifier",
-                                 xmlStrlen (cur2->name)) == 0)
-                              {
-                                xmlChar *val = xmlNodeListGetString (doc,
-                                                                     cur2->
-                                                                     xmlChildrenNode,
-                                                                     1);
-                                if (tmpmaps == NULL)
-                                  {
-                                    tmpmaps = (maps *) malloc (MAPS_SIZE);
-                                    if (tmpmaps == NULL)
-                                      {
-                                        return errorException (m,
-                                                               _
-                                                               ("Unable to allocate memory."),
-                                                               "InternalError",
-                                                               NULL);
-                                      }
-                                    tmpmaps->name = zStrdup ((char *) val);
-                                    tmpmaps->content = NULL;
-                                    tmpmaps->next = NULL;
-                                  }
-                                else
-                                  {
-                                    if (tmpmaps->name != NULL)
-                                      free (tmpmaps->name);
-                                    tmpmaps->name = zStrdup ((char *) val);;
-                                  }
-                                xmlFree (val);
-                              }
-                /**
-		 * Title, Asbtract
-		 */
-                            else
-                              if (xmlStrncasecmp
-                                  (cur2->name, BAD_CAST "Title",
-                                   xmlStrlen (cur2->name)) == 0
-                                  || xmlStrncasecmp (cur2->name,
-                                                     BAD_CAST "Abstract",
-                                                     xmlStrlen (cur2->name))
-                                  == 0)
-                              {
-                                xmlChar *val = xmlNodeListGetString (doc,
-                                                                     cur2->
-                                                                     xmlChildrenNode,
-                                                                     1);
-                                if (tmpmaps == NULL)
-                                  {
-                                    tmpmaps = (maps *) malloc (MAPS_SIZE);
-                                    if (tmpmaps == NULL)
-                                      {
-                                        return errorException (m,
-                                                               _
-                                                               ("Unable to allocate memory."),
-                                                               "InternalError",
-                                                               NULL);
-                                      }
-                                    tmpmaps->name =
-                                      zStrdup ("missingIndetifier");
-                                    tmpmaps->content =
-                                      createMap ((char *) cur2->name,
-                                                 (char *) val);
-                                    tmpmaps->next = NULL;
-                                  }
-                                else
-                                  {
-                                    if (tmpmaps->content != NULL)
-                                      addToMap (tmpmaps->content,
-                                                (char *) cur2->name,
-                                                (char *) val);
-                                    else
-                                      tmpmaps->content =
-                                        createMap ((char *) cur2->name,
-                                                   (char *) val);
-                                  }
-                                xmlFree (val);
-                              }
-                            cur2 = cur2->next;
-                            while (cur2 != NULL
-                                   && cur2->type != XML_ELEMENT_NODE)
-                              cur2 = cur2->next;
-                          }
-                      }
-                    cur1 = cur1->next;
-                    while (cur1 != NULL && cur1->type != XML_ELEMENT_NODE)
-                      cur1 = cur1->next;
-				  
-					if (request_output_real_format == NULL)
-					  request_output_real_format = dupMaps (&tmpmaps);
-					else
-					  addMapsToMaps (&request_output_real_format, tmpmaps);
-                  }
-              }
-          }
+			//map* attributes = NULL;
+			const char *ress[3] =
+			  { "storeExecuteResponse", "lineage", "status" };
+			xmlChar *val;
+			for (int l = 0; l < 3; l++)
+			{
+	#ifdef DEBUG
+				fprintf (stderr, "*** %s ***\t", ress[l]);
+	#endif
+				val = xmlGetProp (cur, BAD_CAST ress[l]);
+				if (val != NULL && strlen ((char *) val) > 0)
+				{
+				/*
+					if (attributes == NULL) {
+						attributes = createMap (ress[l], (char *) val);
+					}
+					else {
+						addToMap (attributes, ress[l], (char *) val);
+					}
+				*/		
+					addToMap (request_inputs, ress[l], (char *) val);
+				  }
+	#ifdef DEBUG
+				fprintf (stderr, "%s\n", val);
+	#endif
+				xmlFree (val);
+			}
+			
+			xmlNodePtr cur1 = cur->children;		
+			while (cur1 != NULL) // iterate over Output nodes
+			{
+				if (cur1->type != XML_ELEMENT_NODE || 
+					xmlStrncasecmp(cur1->name, BAD_CAST "Output", 
+								   xmlStrlen (cur1->name)) != 0) {
+					cur1 = cur1->next;
+					continue;
+				}
+				
+				maps *tmpmaps = (maps *) malloc (MAPS_SIZE); // one per Output node
+				if (tmpmaps == NULL) {
+					return errorException (m,
+										   _
+										   ("Unable to allocate memory."),
+										   "InternalError", NULL);
+				}
+				tmpmaps->name = zStrdup ("unknownIdentifier");
+				tmpmaps->content = NULL;
+				tmpmaps->next = NULL;
+				
+				xmlNodePtr elems = cur1->children;
+				
+				while (elems != NULL) {
+				
+					/**
+					 * Identifier
+					 */		
+					if (xmlStrncasecmp
+						(elems->name, BAD_CAST "Identifier",
+						 xmlStrlen (elems->name)) == 0)
+					{			
+						xmlChar *val =
+						  xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
+						
+						free(tmpmaps->name);
+						tmpmaps->name = zStrdup ((char *) val);  
+						if (tmpmaps->content == NULL) {
+							tmpmaps->content = createMap("Identifier", zStrdup ((char *) val));
+						}
+						else {
+							addToMap(tmpmaps->content, "Identifier", zStrdup ((char *) val));
+						}
+					  
+						map* tt = getMap (request_inputs, "ResponseDocument");				  
+						if (strlen(tt->value) == 0) {
+						  addToMap (request_inputs, "ResponseDocument",
+									(char *) val);							
+						}	
+						else {
+							char* tmp = (char*) malloc((strlen(tt->value) + 1 
+												+ strlen((char*) val) + 1) * sizeof(char));
+							sprintf (tmp, "%s;%s", tt->value, (char *) val);
+							free(tt->value);
+							tt->value = tmp;	
+						}	
+						xmlFree (val);
+					}				
+					/**
+					 * Title, Abstract
+					 */
+					else if (xmlStrncasecmp(elems->name, BAD_CAST "Title",
+											xmlStrlen (elems->name)) == 0
+						  || xmlStrncasecmp(elems->name, BAD_CAST "Abstract",
+										 xmlStrlen (elems->name)) == 0)
+					{
+						xmlChar *val =
+							xmlNodeListGetString (doc, elems->xmlChildrenNode, 1);
+							
+						if (tmpmaps->content == NULL) {
+							tmpmaps->content = createMap((char*) elems->name, zStrdup ((char *) val));
+						}
+						else {
+							addToMap(tmpmaps->content, (char*) elems->name, zStrdup ((char *) val));
+						}
+						xmlFree (val);
+					}
+					elems = elems->next;
+				}
+				
+				/**
+				 * Get every attribute from an Output node:
+				 * mimeType, encoding, schema, uom, asReference
+				 */
+				const char *outs[5] =
+					  { "mimeType", "encoding", "schema", "uom", "asReference" };
+					  
+				for (int l = 0; l < 5; l++) {
+	#ifdef DEBUG
+					fprintf (stderr, "*** %s ***\t", outs[l]);
+	#endif
+					xmlChar *val = xmlGetProp (cur1, BAD_CAST outs[l]);				
+					if (val != NULL && xmlStrlen(val) > 0) {
+						if (tmpmaps->content != NULL) {
+							addToMap (tmpmaps->content, outs[l], (char *) val);
+						}			  
+						else {
+							tmpmaps->content = createMap (outs[l], (char *) val);
+						}	
+					}
+	#ifdef DEBUG
+					fprintf (stderr, "%s\n", val);
+	#endif
+					xmlFree (val);
+				}
+				
+				if (request_output_real_format == NULL) {
+					request_output_real_format = tmpmaps;
+				}	
+				else if (getMaps(request_output_real_format, tmpmaps->name) != NULL) {
+					return errorException (m,
+										   _
+										   ("Duplicate <Output> elements in WPS Execute request"),
+										   "InternalError", NULL);
+				}
+				else {
+					maps* mptr = request_output_real_format;
+					while (mptr->next != NULL) {
+						mptr = mptr->next;
+					}
+					mptr->next = tmpmaps;	
+				}					
+				cur1 = cur1->next;
+			}			 
+		}
+	  } 
       xmlXPathFreeObject (tmpsptr);
       xmlFreeDoc (doc);
