writerperfect/source/common/WPXSvStream.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
  10 #include "WPXSvStream.hxx"
  11 #include <tools/stream.hxx>
  12 #include <unotools/streamwrap.hxx>
  13 #include <unotools/ucbstreamhelper.hxx>
  14 #include <limits>
  15 #include <vector>
  16
  17 using namespace ::com::sun::star::uno;
  18 using namespace ::com::sun::star::io;
  19
  20 namespace
  21 {
  22 static void splitPath( std::vector<OUString> &rElems, const OUString &rPath )
  23 {
  24     for (sal_Int32 i = 0; i >= 0;)
  25         rElems.push_back( rPath.getToken( 0, '/', i ) );
  26 }
  27
  28 } // anonymous namespace
  29
  30 typedef struct
  31 {
  32     SotStorageRef ref;
  33 } SotStorageRefWrapper;
  34
  35 typedef struct
  36 {
  37     SotStorageStreamRef ref;
  38 } SotStorageStreamRefWrapper;
  39
  40 class WPXSvInputStreamImpl : public WPXInputStream
  41 {
  42 public :
  43     WPXSvInputStreamImpl( ::com::sun::star::uno::Reference<
  44                       ::com::sun::star::io::XInputStream > xStream );
  45     ~WPXSvInputStreamImpl();
  46
  47     bool isOLEStream();
  48     WPXInputStream * getDocumentOLEStream(const char *name);
  49
  50     const unsigned char *read(unsigned long numBytes, unsigned long &numBytesRead);
  51     int seek(long offset, WPX_SEEK_TYPE seekType);
  52     long tell();
  53     bool atEOS();
  54 private:
  55     ::std::vector< SotStorageRefWrapper > mxChildrenStorages;
  56     ::std::vector< SotStorageStreamRefWrapper > mxChildrenStreams;
  57     ::com::sun::star::uno::Reference<
  58             ::com::sun::star::io::XInputStream > mxStream;
  59     ::com::sun::star::uno::Reference<
  60             ::com::sun::star::io::XSeekable > mxSeekable;
  61     ::com::sun::star::uno::Sequence< sal_Int8 > maData;
  62     sal_Int64 mnLength;
  63 };
  64
  65 WPXSvInputStreamImpl::WPXSvInputStreamImpl( Reference< XInputStream > xStream ) :
  66     WPXInputStream(),
  67     mxChildrenStorages(),
  68     mxChildrenStreams(),
  69     mxStream(xStream),
  70     mxSeekable(xStream, UNO_QUERY),
  71     maData(0)
  72 {
  73     if (!xStream.is() || !mxStream.is())
  74         mnLength = 0;
  75     else
  76     {
  77         if (!mxSeekable.is())
  78             mnLength = 0;
  79         else
  80         {
  81             try
  82             {
  83                 mnLength = mxSeekable->getLength();
  84             }
  85             catch ( ... )
  86             {
  87                 SAL_WARN("writerperfect", "mnLength = mxSeekable->getLength() threw exception");
  88                 mnLength = 0;
  89             }
  90         }
  91     }
  92 }
  93
  94 WPXSvInputStreamImpl::~WPXSvInputStreamImpl()
  95 {
  96 }
  97
  98 const unsigned char *WPXSvInputStreamImpl::read(unsigned long numBytes, unsigned long &numBytesRead)
  99 {
 100     numBytesRead = 0;
 101
 102     if (numBytes == 0 || atEOS())
 103         return 0;
 104
 105     numBytesRead = mxStream->readSomeBytes (maData, numBytes);
 106     if (numBytesRead == 0)
 107         return 0;
 108
 109     return (const unsigned char *)maData.getConstArray();
 110 }
 111
 112 long WPXSvInputStreamImpl::tell()
 113 {
 114     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
 115         return -1L;
 116     else
 117     {
 118         sal_Int64 tmpPosition = mxSeekable->getPosition();
 119         if ((tmpPosition < 0) || (tmpPosition > (std::numeric_limits<long>::max)()))
 120             return -1L;
 121         return (long)tmpPosition;
 122     }
 123 }
 124
 125 int WPXSvInputStreamImpl::seek(long offset, WPX_SEEK_TYPE seekType)
 126 {
 127     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
 128         return -1;
 129
 130     sal_Int64 tmpPosition = mxSeekable->getPosition();
 131     if ((tmpPosition < 0) || (tmpPosition > (std::numeric_limits<long>::max)()))
 132         return -1;
 133
 134     sal_Int64 tmpOffset = offset;
 135     if (seekType == WPX_SEEK_CUR)
 136         tmpOffset += tmpPosition;
 137     if (seekType == WPX_SEEK_END)
 138         tmpOffset += mnLength;
 139
 140     int retVal = 0;
 141     if (tmpOffset < 0)
 142     {
 143         tmpOffset = 0;
 144         retVal = -1;
 145     }
 146     if (offset > mnLength)
 147     {
 148         tmpOffset = mnLength;
 149         retVal = -1;
 150     }
 151
 152     try
 153     {
 154         mxSeekable->seek(tmpOffset);
 155         return retVal;
 156     }
 157     catch (...)
 158     {
 159         SAL_WARN("writerperfect", "mxSeekable->seek(offset) threw exception");
 160         return -1;
 161     }
 162 }
 163
 164 bool WPXSvInputStreamImpl::atEOS()
 165 {
 166     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
 167         return true;
 168     return (mxSeekable->getPosition() >= mnLength);
 169 }
 170
 171 bool WPXSvInputStreamImpl::isOLEStream()
 172 {
 173     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
 174         return false;
 175
 176     sal_Int64 tmpPosition = mxSeekable->getPosition();
 177     mxSeekable->seek(0);
 178
 179     SvStream *pStream = utl::UcbStreamHelper::CreateStream( mxStream );
 180     bool bAns = pStream && SotStorage::IsOLEStorage( pStream );
 181     if (pStream)
 182         delete pStream;
 183
 184     mxSeekable->seek(tmpPosition);
 185
 186     return bAns;
 187 }
 188
 189 WPXInputStream *WPXSvInputStreamImpl::getDocumentOLEStream(const char *name)
 190 {
 191     if (!name)
 192         return 0;
 193     OUString rPath(name,strlen(name),RTL_TEXTENCODING_UTF8);
 194     std::vector<OUString> aElems;
 195     splitPath( aElems, rPath );
 196
 197     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
 198         return 0;
 199
 200     sal_Int64 tmpPosition = mxSeekable->getPosition();
 201     mxSeekable->seek(0);
 202
 203     SvStream *pStream = utl::UcbStreamHelper::CreateStream( mxStream );
 204
 205     if (!pStream || !SotStorage::IsOLEStorage( pStream ))
 206     {
 207         mxSeekable->seek(tmpPosition);
 208         return 0;
 209     }
 210
 211     SotStorageRefWrapper storageRefWrapper;
 212     storageRefWrapper.ref = new SotStorage( pStream, sal_True );
 213     mxChildrenStorages.push_back( storageRefWrapper );
 214
 215     unsigned i = 0;
 216     while (i < aElems.size())
 217     {
 218         if( mxChildrenStorages.back().ref->IsStream(aElems[i]))
 219             break;
 220         else if (mxChildrenStorages.back().ref->IsStorage(aElems[i]))
 221         {
 222             SotStorageRef tmpParent(mxChildrenStorages.back().ref);
 223             storageRefWrapper.ref = tmpParent->OpenSotStorage(aElems[i++], STREAM_STD_READ);
 224             mxChildrenStorages.push_back(storageRefWrapper);
 225         }
 226         else
 227             // should not happen
 228             return 0;
 229     }
 230
 231     // For the while don't return stream in this situation.
 232     // Later, given how libcdr's zip stream implementation behaves,
 233     // return the first stream in the storage if there is one.
 234     if (i >= aElems.size())
 235         return 0;
 236
 237     SotStorageStreamRefWrapper storageStreamRefWrapper;
 238     storageStreamRefWrapper.ref = mxChildrenStorages.back().ref->OpenSotStream( aElems[i], STREAM_STD_READ );
 239     mxChildrenStreams.push_back( storageStreamRefWrapper );
 240
 241     mxSeekable->seek(tmpPosition);
 242
 243     if ( !mxChildrenStreams.back().ref.Is() || mxChildrenStreams.back().ref->GetError() )
 244     {
 245         mxSeekable->seek(tmpPosition);
 246         return 0;
 247     }
 248
 249     Reference < XInputStream > xContents(new utl::OSeekableInputStreamWrapper( mxChildrenStreams.back().ref ));
 250     mxSeekable->seek(tmpPosition);
 251     if (xContents.is())
 252         return new WPXSvInputStream( xContents );
 253     else
 254         return 0;
 255 }
 256
 257
 258 WPXSvInputStream::WPXSvInputStream( Reference< XInputStream > xStream ) :
 259     mpImpl(new WPXSvInputStreamImpl(xStream))
 260 {
 261 }
 262
 263 WPXSvInputStream::~WPXSvInputStream()
 264 {
 265    delete mpImpl;
 266 }
 267
 268 const unsigned char *WPXSvInputStream::read(unsigned long numBytes, unsigned long &numBytesRead)
 269 {
 270     return mpImpl->read(numBytes, numBytesRead);
 271 }
 272
 273 long WPXSvInputStream::tell()
 274 {
 275     return mpImpl->tell();
 276 }
 277
 278 int WPXSvInputStream::seek(long offset, WPX_SEEK_TYPE seekType)
 279 {
 280     return mpImpl->seek(offset, seekType);
 281 }
 282
 283 bool WPXSvInputStream::atEOS()
 284 {
 285     return mpImpl->atEOS();
 286 }
 287
 288 bool WPXSvInputStream::isOLEStream()
 289 {
 290     return mpImpl->isOLEStream();
 291 }
 292
 293 WPXInputStream *WPXSvInputStream::getDocumentOLEStream(const char *name)
 294 {
 295     return mpImpl->getDocumentOLEStream(name);
 296 }
 297
 298 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */