LCOV - code coverage report
Current view: top level - libreoffice/ucb/source/ucp/webdav-neon - UCBDeadPropertyValue.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 208 0.0 %
Date: 2012-12-27 Functions: 0 12 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*************************************************************************
       3             :  *
       4             :  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       5             :  *
       6             :  * Copyright 2000, 2010 Oracle and/or its affiliates.
       7             :  *
       8             :  * OpenOffice.org - a multi-platform office productivity suite
       9             :  *
      10             :  * This file is part of OpenOffice.org.
      11             :  *
      12             :  * OpenOffice.org is free software: you can redistribute it and/or modify
      13             :  * it under the terms of the GNU Lesser General Public License version 3
      14             :  * only, as published by the Free Software Foundation.
      15             :  *
      16             :  * OpenOffice.org is distributed in the hope that it will be useful,
      17             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      18             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      19             :  * GNU Lesser General Public License version 3 for more details
      20             :  * (a copy is included in the LICENSE file that accompanied this code).
      21             :  *
      22             :  * You should have received a copy of the GNU Lesser General Public License
      23             :  * version 3 along with OpenOffice.org.  If not, see
      24             :  * <http://www.openoffice.org/license.html>
      25             :  * for a copy of the LGPLv3 License.
      26             :  *
      27             :  ************************************************************************/
      28             : 
      29             : 
      30             : #include <string.h>
      31             : #include <ne_xml.h>
      32             : #include <osl/diagnose.h>
      33             : #include <rtl/ustrbuf.hxx>
      34             : #include "UCBDeadPropertyValue.hxx"
      35             : 
      36             : using namespace webdav_ucp;
      37             : using namespace com::sun::star;
      38             : 
      39             : //////////////////////////////////////////////////////////////////////////
      40             : 
      41             : struct UCBDeadPropertyValueParseContext
      42             : {
      43             :     rtl::OUString * pType;
      44             :     rtl::OUString * pValue;
      45             : 
      46           0 :     UCBDeadPropertyValueParseContext() : pType( 0 ), pValue( 0 ) {}
      47           0 :     ~UCBDeadPropertyValueParseContext() { delete pType; delete pValue; }
      48             : };
      49             : 
      50             : // static
      51           0 : const rtl::OUString UCBDeadPropertyValue::aTypeString("string");
      52           0 : const rtl::OUString UCBDeadPropertyValue::aTypeLong("long");
      53           0 : const rtl::OUString UCBDeadPropertyValue::aTypeShort("short");
      54           0 : const rtl::OUString UCBDeadPropertyValue::aTypeBoolean("boolean");
      55           0 : const rtl::OUString UCBDeadPropertyValue::aTypeChar("char");
      56           0 : const rtl::OUString UCBDeadPropertyValue::aTypeByte("byte");
      57           0 : const rtl::OUString UCBDeadPropertyValue::aTypeHyper("hyper");
      58           0 : const rtl::OUString UCBDeadPropertyValue::aTypeFloat("float");
      59           0 : const rtl::OUString UCBDeadPropertyValue::aTypeDouble("double");
      60             : 
      61             : // static
      62           0 : const rtl::OUString UCBDeadPropertyValue::aXMLPre("<ucbprop><type>");
      63           0 : const rtl::OUString UCBDeadPropertyValue::aXMLMid("</type><value>");
      64           0 : const rtl::OUString UCBDeadPropertyValue::aXMLEnd("</value></ucbprop>");
      65             : 
      66             : #define STATE_TOP (1)
      67             : 
      68             : #define STATE_UCBPROP   (STATE_TOP)
      69             : #define STATE_TYPE      (STATE_TOP + 1)
      70             : #define STATE_VALUE     (STATE_TOP + 2)
      71             : 
      72             : //////////////////////////////////////////////////////////////////////////
      73           0 : extern "C" int UCBDeadPropertyValue_startelement_callback(
      74             :     void *,
      75             :     int parent,
      76             :     const char * /*nspace*/,
      77             :     const char *name,
      78             :     const char ** )
      79             : {
      80           0 :     if ( name != 0 )
      81             :     {
      82           0 :         switch ( parent )
      83             :         {
      84             :             case NE_XML_STATEROOT:
      85           0 :                 if ( strcmp( name, "ucbprop" ) == 0 )
      86           0 :                     return STATE_UCBPROP;
      87           0 :                 break;
      88             : 
      89             :             case STATE_UCBPROP:
      90           0 :                 if ( strcmp( name, "type" ) == 0 )
      91           0 :                     return STATE_TYPE;
      92           0 :                 else if ( strcmp( name, "value" ) == 0 )
      93           0 :                     return STATE_VALUE;
      94           0 :                 break;
      95             :         }
      96             :     }
      97           0 :     return NE_XML_DECLINE;
      98             : }
      99             : 
     100             : //////////////////////////////////////////////////////////////////////////
     101           0 : extern "C" int UCBDeadPropertyValue_chardata_callback(
     102             :     void *userdata,
     103             :     int state,
     104             :     const char *buf,
     105             :     size_t len )
     106             : {
     107             :     UCBDeadPropertyValueParseContext * pCtx
     108           0 :             = static_cast< UCBDeadPropertyValueParseContext * >( userdata );
     109             : 
     110           0 :     switch ( state )
     111             :     {
     112             :         case STATE_TYPE:
     113             :             OSL_ENSURE( !pCtx->pType,
     114             :                         "UCBDeadPropertyValue_endelement_callback - "
     115             :                         "Type already set!" );
     116             :             pCtx->pType
     117           0 :                 = new rtl::OUString( buf, len, RTL_TEXTENCODING_ASCII_US );
     118           0 :             break;
     119             : 
     120             :         case STATE_VALUE:
     121             :             OSL_ENSURE( !pCtx->pValue,
     122             :                         "UCBDeadPropertyValue_endelement_callback - "
     123             :                         "Value already set!" );
     124             :             pCtx->pValue
     125           0 :                 = new rtl::OUString( buf, len, RTL_TEXTENCODING_ASCII_US );
     126           0 :             break;
     127             :     }
     128           0 :     return 0; // zero to continue, non-zero to abort parsing
     129             : }
     130             : 
     131             : //////////////////////////////////////////////////////////////////////////
     132           0 : extern "C" int UCBDeadPropertyValue_endelement_callback(
     133             :     void *userdata,
     134             :     int state,
     135             :     const char *,
     136             :     const char * )
     137             : {
     138             :     UCBDeadPropertyValueParseContext * pCtx
     139           0 :             = static_cast< UCBDeadPropertyValueParseContext * >( userdata );
     140             : 
     141           0 :     switch ( state )
     142             :     {
     143             :         case STATE_TYPE:
     144           0 :             if ( !pCtx->pType )
     145           0 :                 return 1; // abort
     146           0 :             break;
     147             : 
     148             :         case STATE_VALUE:
     149           0 :             if ( !pCtx->pValue )
     150           0 :                 return 1; // abort
     151           0 :             break;
     152             : 
     153             :         case STATE_UCBPROP:
     154           0 :             if ( !pCtx->pType || ! pCtx->pValue )
     155           0 :                 return 1; // abort
     156           0 :             break;
     157             :     }
     158           0 :     return 0; // zero to continue, non-zero to abort parsing
     159             : }
     160             : 
     161             : //////////////////////////////////////////////////////////////////////////
     162           0 : static rtl::OUString encodeValue( const rtl::OUString & rValue )
     163             : {
     164             :     // Note: I do not use the usual &amp; + &lt; + &gt; encoding, because
     165             :     //       I want to prevent any XML parser from trying to 'understand'
     166             :     //       the value. This caused problems:
     167             :     //
     168             :     //       Example:
     169             :     //       - Unencoded property value: x<z
     170             :     //       PROPPATCH:
     171             :     //       - Encoded property value: x&lt;z
     172             :     //       - UCBDeadPropertyValue::toXML result:
     173             :     //              <ucbprop><type>string</type><value>x&lt;z</value></ucbprop>
     174             :     //       PROPFIND:
     175             :     //       - parser replaces &lt; by > ==> error (not well formed)
     176             : 
     177           0 :     rtl::OUStringBuffer aResult;
     178           0 :     const sal_Unicode * pValue = rValue.getStr();
     179             : 
     180           0 :     sal_Int32 nCount = rValue.getLength();
     181           0 :     for ( sal_Int32 n = 0; n < nCount; ++n )
     182             :     {
     183           0 :         const sal_Unicode c = pValue[ n ];
     184             : 
     185           0 :         if ( '%' == c )
     186           0 :             aResult.appendAscii( "%per;" );
     187           0 :         else if ( '<' == c )
     188           0 :             aResult.appendAscii( "%lt;" );
     189           0 :         else if ( '>' == c )
     190           0 :             aResult.appendAscii( "%gt;" );
     191             :         else
     192           0 :             aResult.append( c );
     193             :     }
     194           0 :     return aResult.makeStringAndClear();
     195             : }
     196             : 
     197             : //////////////////////////////////////////////////////////////////////////
     198           0 : static rtl::OUString decodeValue( const rtl::OUString & rValue )
     199             : {
     200           0 :     rtl::OUStringBuffer aResult;
     201           0 :     const sal_Unicode * pValue = rValue.getStr();
     202             : 
     203           0 :     sal_Int32 nPos = 0;
     204           0 :     sal_Int32 nEnd = rValue.getLength();
     205             : 
     206           0 :     while ( nPos < nEnd )
     207             :     {
     208           0 :         sal_Unicode c = pValue[ nPos ];
     209             : 
     210           0 :         if ( '%' == c )
     211             :         {
     212           0 :             nPos++;
     213             : 
     214           0 :             if ( nPos == nEnd )
     215             :             {
     216             :                 OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     217           0 :                 return rtl::OUString();
     218             :             }
     219             : 
     220           0 :             c = pValue[ nPos ];
     221             : 
     222           0 :             if ( 'p' == c )
     223             :             {
     224             :                 // %per;
     225             : 
     226           0 :                 if ( nPos > nEnd - 4 )
     227             :                 {
     228             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     229           0 :                     return rtl::OUString();
     230             :                 }
     231             : 
     232           0 :                 if ( ( 'e' == pValue[ nPos + 1 ] )
     233             :                      &&
     234           0 :                      ( 'r' == pValue[ nPos + 2 ] )
     235             :                      &&
     236           0 :                      ( ';' == pValue[ nPos + 3 ] ) )
     237             :                 {
     238           0 :                     aResult.append( sal_Unicode( '%' ) );
     239           0 :                     nPos += 3;
     240             :                 }
     241             :                 else
     242             :                 {
     243             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     244           0 :                     return rtl::OUString();
     245             :                 }
     246             :             }
     247           0 :             else if ( 'l' == c )
     248             :             {
     249             :                 // %lt;
     250             : 
     251           0 :                 if ( nPos > nEnd - 3 )
     252             :                 {
     253             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     254           0 :                     return rtl::OUString();
     255             :                 }
     256             : 
     257           0 :                 if ( ( 't' == pValue[ nPos + 1 ] )
     258             :                      &&
     259           0 :                      ( ';' == pValue[ nPos + 2 ] ) )
     260             :                 {
     261           0 :                     aResult.append( sal_Unicode( '<' ) );
     262           0 :                     nPos += 2;
     263             :                 }
     264             :                 else
     265             :                 {
     266             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     267           0 :                     return rtl::OUString();
     268             :                 }
     269             :             }
     270           0 :             else if ( 'g' == c )
     271             :             {
     272             :                 // %gt;
     273             : 
     274           0 :                 if ( nPos > nEnd - 3 )
     275             :                 {
     276             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     277           0 :                     return rtl::OUString();
     278             :                 }
     279             : 
     280           0 :                 if ( ( 't' == pValue[ nPos + 1 ] )
     281             :                      &&
     282           0 :                      ( ';' == pValue[ nPos + 2 ] ) )
     283             :                 {
     284           0 :                     aResult.append( sal_Unicode( '>' ) );
     285           0 :                     nPos += 2;
     286             :                 }
     287             :                 else
     288             :                 {
     289             :                     OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     290           0 :                     return rtl::OUString();
     291             :                 }
     292             :             }
     293             :             else
     294             :             {
     295             :                 OSL_FAIL( "UCBDeadPropertyValue::decodeValue - syntax error!" );
     296           0 :                 return rtl::OUString();
     297             :             }
     298             :         }
     299             :         else
     300           0 :             aResult.append( c );
     301             : 
     302           0 :         nPos++;
     303             :     }
     304             : 
     305           0 :     return aResult.makeStringAndClear();
     306             : }
     307             : 
     308             : //////////////////////////////////////////////////////////////////////////
     309             : // static
     310           0 : bool UCBDeadPropertyValue::supportsType( const uno::Type & rType )
     311             : {
     312           0 :     if ( ( rType != getCppuType( static_cast< const rtl::OUString * >( 0 ) ) )
     313             :          &&
     314           0 :          ( rType != getCppuType( static_cast< const sal_Int32 * >( 0 ) ) )
     315             :          &&
     316           0 :          ( rType != getCppuType( static_cast< const sal_Int16 * >( 0 ) ) )
     317             :          &&
     318           0 :          ( rType != getCppuBooleanType() )
     319             :          &&
     320           0 :          ( rType != getCppuCharType() )
     321             :          &&
     322           0 :          ( rType != getCppuType( static_cast< const sal_Int8 * >( 0 ) ) )
     323             :          &&
     324           0 :          ( rType != getCppuType( static_cast< const sal_Int64 * >( 0 ) ) )
     325             :          &&
     326           0 :          ( rType != getCppuType( static_cast< const float * >( 0 ) ) )
     327             :          &&
     328           0 :          ( rType != getCppuType( static_cast< const double * >( 0 ) ) ) )
     329             :     {
     330           0 :         return false;
     331             :     }
     332             : 
     333           0 :     return true;
     334             : }
     335             : 
     336             : //////////////////////////////////////////////////////////////////////////
     337             : // static
     338           0 : bool UCBDeadPropertyValue::createFromXML( const rtl::OString & rInData,
     339             :                                           uno::Any & rOutData )
     340             : {
     341           0 :     bool success = false;
     342             : 
     343           0 :     ne_xml_parser * parser = ne_xml_create();
     344           0 :     if ( parser )
     345             :     {
     346           0 :         UCBDeadPropertyValueParseContext aCtx;
     347             :         ne_xml_push_handler( parser,
     348             :                              UCBDeadPropertyValue_startelement_callback,
     349             :                              UCBDeadPropertyValue_chardata_callback,
     350             :                              UCBDeadPropertyValue_endelement_callback,
     351           0 :                              &aCtx );
     352             : 
     353           0 :         ne_xml_parse( parser, rInData.getStr(), rInData.getLength() );
     354             : 
     355           0 :         success = !ne_xml_failed( parser );
     356             : 
     357           0 :         ne_xml_destroy( parser );
     358             : 
     359           0 :         if ( success )
     360             :         {
     361           0 :             if ( aCtx.pType && aCtx.pValue )
     362             :             {
     363             :                 // Decode aCtx.pValue! It may contain XML reserved chars.
     364           0 :                 rtl::OUString aStringValue = decodeValue( *aCtx.pValue );
     365           0 :                 if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeString ) )
     366             :                 {
     367           0 :                     rOutData <<= aStringValue;
     368             :                 }
     369           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeLong ) )
     370             :                 {
     371           0 :                     rOutData <<= aStringValue.toInt32();
     372             :                 }
     373           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeShort ) )
     374             :                 {
     375           0 :                     rOutData <<= sal_Int16( aStringValue.toInt32() );
     376             :                 }
     377           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeBoolean ) )
     378             :                 {
     379           0 :                     if ( aStringValue.equalsIgnoreAsciiCase(
     380           0 :                             rtl::OUString("true") ) )
     381           0 :                         rOutData <<= sal_Bool( sal_True );
     382             :                     else
     383           0 :                         rOutData <<= sal_Bool( sal_False );
     384             :                 }
     385           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeChar ) )
     386             :                 {
     387           0 :                     rOutData <<= aStringValue.toChar();
     388             :                 }
     389           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeByte ) )
     390             :                 {
     391           0 :                     rOutData <<= sal_Int8( aStringValue.toChar() );
     392             :                 }
     393           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeHyper ) )
     394             :                 {
     395           0 :                     rOutData <<= aStringValue.toInt64();
     396             :                 }
     397           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeFloat ) )
     398             :                 {
     399           0 :                     rOutData <<= aStringValue.toFloat();
     400             :                 }
     401           0 :                 else if ( aCtx.pType->equalsIgnoreAsciiCase( aTypeDouble ) )
     402             :                 {
     403           0 :                     rOutData <<= aStringValue.toDouble();
     404             :                 }
     405             :                 else
     406             :                 {
     407             :                     OSL_FAIL( "UCBDeadPropertyValue::createFromXML - "
     408             :                                 "Unsupported property type!" );
     409           0 :                     success = false;
     410           0 :                 }
     411             :             }
     412             :             else
     413           0 :                 success = false;
     414           0 :         }
     415             :     }
     416             : 
     417           0 :     return success;
     418             : }
     419             : 
     420             : //////////////////////////////////////////////////////////////////////////
     421             : // static
     422           0 : bool UCBDeadPropertyValue::toXML( const uno::Any & rInData,
     423             :                                   rtl::OUString & rOutData )
     424             : {
     425             :     // <ucbprop><type>the_type</type><value>the_value</value></ucbprop>
     426             : 
     427             :     // Check property type. Extract type and value as string.
     428             : 
     429           0 :     const uno::Type& rType = rInData.getValueType();
     430           0 :     rtl::OUString aStringValue;
     431           0 :     rtl::OUString aStringType;
     432             : 
     433           0 :     if ( rType == getCppuType( static_cast< const rtl::OUString * >( 0 ) ) )
     434             :     {
     435             :         // string
     436           0 :         rInData >>= aStringValue;
     437           0 :         aStringType = aTypeString;
     438             :     }
     439           0 :     else if ( rType == getCppuType( static_cast< const sal_Int32 * >( 0 ) ) )
     440             :     {
     441             :         // long
     442           0 :         sal_Int32 nValue = 0;
     443           0 :         rInData >>= nValue;
     444           0 :         aStringValue = rtl::OUString::valueOf( nValue );
     445           0 :         aStringType = aTypeLong;
     446             :     }
     447           0 :     else if ( rType == getCppuType( static_cast< const sal_Int16 * >( 0 ) ) )
     448             :     {
     449             :         // short
     450           0 :         sal_Int32 nValue = 0;
     451           0 :         rInData >>= nValue;
     452           0 :         aStringValue = rtl::OUString::valueOf( nValue );
     453           0 :         aStringType = aTypeShort;
     454             :     }
     455           0 :     else if ( rType == getCppuBooleanType() )
     456             :     {
     457             :         // boolean
     458           0 :         sal_Bool bValue = false;
     459           0 :         rInData >>= bValue;
     460           0 :         aStringValue = rtl::OUString::valueOf( bValue );
     461           0 :         aStringType = aTypeBoolean;
     462             :     }
     463           0 :     else if ( rType == getCppuCharType() )
     464             :     {
     465             :         // char
     466           0 :         sal_Unicode cValue = 0;
     467           0 :         rInData >>= cValue;
     468           0 :         aStringValue = rtl::OUString::valueOf( cValue );
     469           0 :         aStringType = aTypeChar;
     470             :     }
     471           0 :     else if ( rType == getCppuType( static_cast< const sal_Int8 * >( 0 ) ) )
     472             :     {
     473             :         // byte
     474           0 :         sal_Int8 nValue = 0;
     475           0 :         rInData >>= nValue;
     476           0 :         aStringValue = rtl::OUString::valueOf( sal_Unicode( nValue ) );
     477           0 :         aStringType = aTypeByte;
     478             :     }
     479           0 :     else if ( rType == getCppuType( static_cast< const sal_Int64 * >( 0 ) ) )
     480             :     {
     481             :         // hyper
     482           0 :         sal_Int64 nValue = 0;
     483           0 :         rInData >>= nValue;
     484           0 :         aStringValue = rtl::OUString::valueOf( nValue );
     485           0 :         aStringType = aTypeHyper;
     486             :     }
     487           0 :     else if ( rType == getCppuType( static_cast< const float * >( 0 ) ) )
     488             :     {
     489             :         // float
     490           0 :         float nValue = 0;
     491           0 :         rInData >>= nValue;
     492           0 :         aStringValue = rtl::OUString::valueOf( nValue );
     493           0 :         aStringType = aTypeFloat;
     494             :     }
     495           0 :     else if ( rType == getCppuType( static_cast< const double * >( 0 ) ) )
     496             :     {
     497             :         // double
     498           0 :         double nValue = 0;
     499           0 :         rInData >>= nValue;
     500           0 :         aStringValue = rtl::OUString::valueOf( nValue );
     501           0 :         aStringType = aTypeDouble;
     502             :     }
     503             :     else
     504             :     {
     505             :         OSL_FAIL( "UCBDeadPropertyValue::toXML - "
     506             :                     "Unsupported property type!" );
     507           0 :         return false;
     508             :     }
     509             : 
     510             :     // Encode value! It must not contain XML reserved chars!
     511           0 :     aStringValue = encodeValue( aStringValue );
     512             : 
     513           0 :         rOutData =  aXMLPre;
     514           0 :     rOutData += aStringType;
     515           0 :     rOutData += aXMLMid;
     516           0 :     rOutData += aStringValue;
     517           0 :     rOutData += aXMLEnd;
     518             : 
     519           0 :     return true;
     520           0 : }
     521             : 
     522             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10