forms/source/xforms/submission/serialization_urlencoded.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <com/sun/star/io/Pipe.hpp>
  22 #include <com/sun/star/xml/xpath/XPathObjectType.hpp>
  23 #include <com/sun/star/xml/dom/XNode.hpp>
  24 #include <com/sun/star/xml/dom/XText.hpp>
  25 #include <com/sun/star/xml/dom/XNodeList.hpp>
  26 #include <com/sun/star/xml/dom/NodeType.hpp>
  27
  28 #include <rtl/ustrbuf.hxx>
  29 #include <rtl/strbuf.hxx>
  30 #include <comphelper/processfactory.hxx>
  31 #include <comphelper/string.hxx>
  32
  33 #include <stdio.h>
  34
  35 #include "serialization_urlencoded.hxx"
  36
  37 using namespace css::uno;
  38 using namespace css::io;
  39 using namespace css::xml::xpath;
  40 using namespace css::xml::dom;
  41
  42 CSerializationURLEncoded::CSerializationURLEncoded()
  43     : m_aPipe(Pipe::create(comphelper::getProcessComponentContext()))
  44 {
  45 }
  46
  47
  48 /*
  49  rfc2396
  50  reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
  51                     "$" | ","
  52  mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
  53  unreserved = alphanum | mark
  54 */
  55 bool CSerializationURLEncoded::is_unreserved(sal_Char c)
  56 {
  57     if (comphelper::string::isalnumAscii(c))
  58         return true;
  59     switch (c) {
  60         case '-':
  61         case '_':
  62         case '.':
  63         case '!':
  64         case '~':
  65         case '*':
  66         case '\'':
  67         case '(':
  68         case ')':
  69             return true;
  70     }
  71     return false;
  72 }
  73 void  CSerializationURLEncoded::encode_and_append(const OUString& aString, OStringBuffer& aBuffer)
  74 {
  75     OString utf8String = OUStringToOString(aString, RTL_TEXTENCODING_UTF8);
  76     const sal_uInt8 *pString = reinterpret_cast< const sal_uInt8 * >( utf8String.getStr() );
  77     sal_Char tmpChar[4]; tmpChar[3] = 0;
  78
  79     while( *pString != 0)
  80     {
  81         if( *pString < 0x80 )
  82         {
  83             if ( is_unreserved(*pString) ) {
  84                 aBuffer.append(*pString);
  85             } else if (*pString == 0x20) {
  86                 aBuffer.append('+');
  87             } else if (*pString == 0x0d && *(pString+1) == 0x0a) {
  88                 aBuffer.append("%0D%0A");
  89                 pString++;
  90             } else if (*pString == 0x0a) {
  91                 aBuffer.append("%0D%0A");
  92             } else {
  93                 snprintf(tmpChar, 3, "%%%X", *pString % 0x100);
  94                 aBuffer.append(tmpChar);
  95             }
  96         } else {
  97             snprintf(tmpChar, 3, "%%%X", *pString % 0x100);
  98             aBuffer.append(tmpChar);
  99             while (*pString >= 0x80) {
 100                 // continuation...
 101                 pString++;
 102                 snprintf(tmpChar, 3, "%%%X", *pString % 0x100);
 103                 aBuffer.append(tmpChar);
 104             }
 105         }
 106         pString++;
 107     }
 108 }
 109
 110 void CSerializationURLEncoded::serialize_node(const Reference< XNode >& aNode)
 111 {
 112     // serialize recursive
 113     // every element node E that has a text child T will be serialized in document order
 114     // <E1>T1<E2>T2</E2></E1><E3>T3</E3> -> E1=T2&E2=T2&E3=T3 (En := local name)
 115
 116     // this node
 117     Reference< XNodeList > aChildList = aNode->getChildNodes();
 118     Reference< XNode > aChild;
 119     // is this an element node?
 120     if (aNode->getNodeType() == NodeType_ELEMENT_NODE)
 121     {
 122         OUString  aName = aNode->getNodeName();
 123         // find any text children
 124         OUStringBuffer aValue;
 125         Reference< XText > aText;
 126         for(sal_Int32 i=0; i < aChildList->getLength(); i++)
 127         {
 128             aChild = aChildList->item(i);
 129             if (aChild->getNodeType() == NodeType_TEXT_NODE)
 130             {
 131                 aText = Reference< XText >(aChild, UNO_QUERY);
 132                 aValue.append(aText->getData());
 133             }
 134         }
 135
 136         // found anything?
 137         if (!aValue.isEmpty())
 138         {
 139             OUString aUnencValue = aValue.makeStringAndClear();
 140             OStringBuffer aEncodedBuffer;
 141             encode_and_append(aName, aEncodedBuffer);
 142             aEncodedBuffer.append("=");
 143             encode_and_append(aUnencValue, aEncodedBuffer);
 144             aEncodedBuffer.append("&");
 145             sal_Int8 const *pData = reinterpret_cast<sal_Int8 const *>(aEncodedBuffer.getStr());
 146             Sequence< sal_Int8 > sData(pData, aEncodedBuffer.getLength());
 147             m_aPipe->writeBytes(sData);
 148         }
 149     }
 150
 151     // element children...
 152     for(sal_Int32 i=0; i < aChildList->getLength(); i++)
 153     {
 154         aChild = aChildList->item(i);
 155         // if this is an element node, it might be a candidate for serialization
 156         if (aChild.is() && aChild->getNodeType() == NodeType_ELEMENT_NODE)
 157             serialize_node(aChild);
 158     }
 159 }
 160
 161 void CSerializationURLEncoded::serialize()
 162 {
 163
 164     // output stream to the pipe buffer
 165     Reference< XOutputStream > out(m_aPipe, UNO_QUERY);
 166
 167     css::uno::Reference< css::xml::dom::XNode > cur = m_aFragment->getFirstChild();
 168     while (cur.is())
 169     {
 170         serialize_node(cur);
 171         cur = cur->getNextSibling();
 172     }
 173     m_aPipe->closeOutput();
 174 }
 175
 176 Reference< XInputStream > CSerializationURLEncoded::getInputStream()
 177 {
 178     return Reference< XInputStream >(m_aPipe, UNO_QUERY);
 179 }
 180
 181
 182 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */