Line data Source code
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 : #include "scriptcont.hxx"
21 : #include <com/sun/star/container/XNameContainer.hpp>
22 : #include <com/sun/star/xml/sax/Parser.hpp>
23 : #include <com/sun/star/xml/sax/InputSource.hpp>
24 : #include <com/sun/star/xml/sax/Writer.hpp>
25 : #include <com/sun/star/io/XOutputStream.hpp>
26 : #include <com/sun/star/io/XInputStream.hpp>
27 : #include <com/sun/star/io/XActiveDataSource.hpp>
28 : #include <com/sun/star/ucb/XSimpleFileAccess3.hpp>
29 : #include <com/sun/star/embed/ElementModes.hpp>
30 : #include <com/sun/star/embed/XEncryptionProtectedSource.hpp>
31 : #include <com/sun/star/beans/XPropertySet.hpp>
32 : #include <com/sun/star/embed/XTransactedObject.hpp>
33 : #include <com/sun/star/task/ErrorCodeIOException.hpp>
34 : #include <com/sun/star/script/ModuleType.hpp>
35 : #include <comphelper/processfactory.hxx>
36 : #include <comphelper/storagehelper.hxx>
37 : #include <unotools/streamwrap.hxx>
38 : #include <unotools/ucbstreamhelper.hxx>
39 : #include <osl/mutex.hxx>
40 : #include <osl/thread.h>
41 : #include <rtl/digest.h>
42 : #include <rtl/strbuf.hxx>
43 :
44 : // For password functionality
45 : #include <tools/urlobj.hxx>
46 :
47 :
48 : #include <unotools/pathoptions.hxx>
49 : #include <svtools/sfxecode.hxx>
50 : #include <svtools/ehdl.hxx>
51 : #include <basic/basmgr.hxx>
52 : #include <basic/sbmod.hxx>
53 : #include <basic/basicmanagerrepository.hxx>
54 : #include <basic/modsizeexceeded.hxx>
55 : #include <xmlscript/xmlmod_imexp.hxx>
56 : #include <cppuhelper/factory.hxx>
57 : #include <com/sun/star/util/VetoException.hpp>
58 : #include <com/sun/star/script/XLibraryQueryExecutable.hpp>
59 : #include <cppuhelper/implbase1.hxx>
60 : #include <boost/scoped_ptr.hpp>
61 :
62 : namespace basic
63 : {
64 :
65 : using namespace com::sun::star::document;
66 : using namespace com::sun::star::container;
67 : using namespace com::sun::star::io;
68 : using namespace com::sun::star::uno;
69 : using namespace com::sun::star::ucb;
70 : using namespace com::sun::star::lang;
71 : using namespace com::sun::star::script;
72 : using namespace com::sun::star::xml::sax;
73 : using namespace com::sun::star;
74 : using namespace cppu;
75 : using namespace osl;
76 :
77 :
78 : // Implementation class SfxScriptLibraryContainer
79 :
80 3966 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getInfoFileName() const { return "script"; }
81 3966 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getOldInfoFileName() const { return "script"; }
82 3966 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibElementFileExtension() const { return "xba"; }
83 3966 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibrariesDir() const { return "Basic"; }
84 :
85 : // OldBasicPassword interface
86 0 : void SfxScriptLibraryContainer::setLibraryPassword( const OUString& rLibraryName, const OUString& rPassword )
87 : {
88 : try
89 : {
90 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
91 0 : if( !rPassword.isEmpty() )
92 : {
93 0 : pImplLib->mbDoc50Password = true;
94 0 : pImplLib->mbPasswordProtected = true;
95 0 : pImplLib->maPassword = rPassword;
96 : }
97 : }
98 0 : catch(const NoSuchElementException& ) {}
99 0 : }
100 :
101 0 : OUString SfxScriptLibraryContainer::getLibraryPassword( const OUString& rLibraryName )
102 : {
103 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
104 0 : OUString aPassword;
105 0 : if( pImplLib->mbPasswordVerified )
106 : {
107 0 : aPassword = pImplLib->maPassword;
108 : }
109 0 : return aPassword;
110 : }
111 :
112 0 : void SfxScriptLibraryContainer::clearLibraryPassword( const OUString& rLibraryName )
113 : {
114 : try
115 : {
116 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
117 0 : pImplLib->mbDoc50Password = false;
118 0 : pImplLib->mbPasswordProtected = false;
119 0 : pImplLib->maPassword.clear();
120 : }
121 0 : catch(const NoSuchElementException& ) {}
122 0 : }
123 :
124 0 : bool SfxScriptLibraryContainer::hasLibraryPassword( const OUString& rLibraryName )
125 : {
126 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
127 0 : return pImplLib->mbPasswordProtected;
128 : }
129 :
130 : // Ctor for service
131 3970 : SfxScriptLibraryContainer::SfxScriptLibraryContainer()
132 3970 : :maScriptLanguage( "StarBasic" )
133 : {
134 : // all initialisation has to be done
135 : // by calling XInitialization::initialize
136 3970 : }
137 :
138 112 : SfxScriptLibraryContainer::SfxScriptLibraryContainer( const uno::Reference< embed::XStorage >& xStorage )
139 113 : :maScriptLanguage( "StarBasic" )
140 : {
141 113 : init( OUString(), xStorage );
142 111 : }
143 :
144 : // Methods to get library instances of the correct type
145 2106 : SfxLibrary* SfxScriptLibraryContainer::implCreateLibrary( const OUString& aName )
146 : {
147 : (void)aName; // Only needed for SfxDialogLibrary
148 2106 : SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxContext, mxSFI );
149 2106 : return pRet;
150 : }
151 :
152 999 : SfxLibrary* SfxScriptLibraryContainer::implCreateLibraryLink( const OUString& aName,
153 : const OUString& aLibInfoFileURL,
154 : const OUString& StorageURL,
155 : bool ReadOnly )
156 : {
157 : (void)aName; // Only needed for SfxDialogLibrary
158 : SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxContext, mxSFI,
159 999 : aLibInfoFileURL, StorageURL, ReadOnly );
160 999 : return pRet;
161 : }
162 :
163 1070 : Any SAL_CALL SfxScriptLibraryContainer::createEmptyLibraryElement()
164 : {
165 1070 : OUString aMod;
166 1070 : Any aRetAny;
167 1070 : aRetAny <<= aMod;
168 1070 : return aRetAny;
169 : }
170 :
171 1 : bool SAL_CALL SfxScriptLibraryContainer::isLibraryElementValid(const Any& rElement) const
172 : {
173 1 : return SfxScriptLibrary::containsValidModule(rElement);
174 : }
175 :
176 1 : void SAL_CALL SfxScriptLibraryContainer::writeLibraryElement( const Reference < XNameContainer >& xLib,
177 : const OUString& aElementName,
178 : const Reference< XOutputStream >& xOutput)
179 : throw(Exception)
180 : {
181 : // Create sax writer
182 1 : Reference< XWriter > xWriter = xml::sax::Writer::create(mxContext);
183 :
184 2 : Reference< XTruncate > xTruncate( xOutput, UNO_QUERY );
185 : OSL_ENSURE( xTruncate.is(), "Currently only the streams that can be truncated are expected!" );
186 1 : if ( xTruncate.is() )
187 : {
188 1 : xTruncate->truncate();
189 : }
190 1 : xWriter->setOutputStream( xOutput );
191 :
192 2 : xmlscript::ModuleDescriptor aMod;
193 1 : aMod.aName = aElementName;
194 1 : aMod.aLanguage = maScriptLanguage;
195 2 : Any aElement = xLib->getByName( aElementName );
196 1 : aElement >>= aMod.aCode;
197 :
198 2 : Reference< script::vba::XVBAModuleInfo > xModInfo( xLib, UNO_QUERY );
199 1 : if( xModInfo.is() && xModInfo->hasModuleInfo( aElementName ) )
200 : {
201 0 : script::ModuleInfo aModInfo = xModInfo->getModuleInfo( aElementName );
202 0 : switch( aModInfo.ModuleType )
203 : {
204 : case ModuleType::NORMAL:
205 0 : aMod.aModuleType = "normal";
206 0 : break;
207 : case ModuleType::CLASS:
208 0 : aMod.aModuleType ="class";
209 0 : break;
210 : case ModuleType::FORM:
211 0 : aMod.aModuleType = "form";
212 0 : break;
213 : case ModuleType::DOCUMENT:
214 0 : aMod.aModuleType = "document";
215 0 : break;
216 : case ModuleType::UNKNOWN:
217 : // nothing
218 0 : break;
219 0 : }
220 : }
221 :
222 2 : xmlscript::exportScriptModule( xWriter, aMod );
223 1 : }
224 :
225 :
226 72 : Any SAL_CALL SfxScriptLibraryContainer::importLibraryElement
227 : ( const Reference < XNameContainer >& xLib,
228 : const OUString& aElementName, const OUString& aFile,
229 : const uno::Reference< io::XInputStream >& xInStream )
230 : {
231 72 : Any aRetAny;
232 :
233 144 : Reference< XParser > xParser = xml::sax::Parser::create( mxContext );
234 :
235 : // Read from storage?
236 72 : bool bStorage = xInStream.is();
237 144 : Reference< XInputStream > xInput;
238 :
239 72 : if( bStorage )
240 : {
241 11 : xInput = xInStream;
242 : }
243 : else
244 : {
245 : try
246 : {
247 61 : xInput = mxSFI->openFileRead( aFile );
248 : }
249 0 : catch(const Exception& )
250 : //catch( Exception& e )
251 : {
252 : // TODO:
253 : //throw WrappedTargetException( e );
254 : }
255 : }
256 :
257 72 : if( !xInput.is() )
258 0 : return aRetAny;
259 :
260 144 : InputSource source;
261 72 : source.aInputStream = xInput;
262 72 : source.sSystemId = aFile;
263 :
264 : // start parsing
265 144 : xmlscript::ModuleDescriptor aMod;
266 :
267 : try
268 : {
269 72 : xParser->setDocumentHandler( ::xmlscript::importScriptModule( aMod ) );
270 72 : xParser->parseStream( source );
271 : }
272 0 : catch(const Exception& )
273 : {
274 0 : SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFile );
275 0 : ErrorHandler::HandleError( ERRCODE_IO_GENERAL );
276 : }
277 :
278 72 : aRetAny <<= aMod.aCode;
279 :
280 : // TODO: Check language
281 : // aMod.aLanguage
282 : // aMod.aName ignored
283 72 : if( !aMod.aModuleType.isEmpty() )
284 : {
285 : /* If in VBA compatibility mode, force creation of the VBA Globals
286 : object. Each application will create an instance of its own
287 : implementation and store it in its Basic manager. Implementations
288 : will do all necessary additional initialization, such as
289 : registering the global "This***Doc" UNO constant, starting the
290 : document events processor etc.
291 : */
292 0 : if( getVBACompatibilityMode() ) try
293 : {
294 0 : Reference< frame::XModel > xModel( mxOwnerDocument ); // weak-ref -> ref
295 0 : Reference< XMultiServiceFactory > xFactory( xModel, UNO_QUERY_THROW );
296 0 : xFactory->createInstance("ooo.vba.VBAGlobals");
297 : }
298 0 : catch(const Exception& )
299 : {
300 : }
301 :
302 0 : script::ModuleInfo aModInfo;
303 0 : aModInfo.ModuleType = ModuleType::UNKNOWN;
304 0 : if( aMod.aModuleType == "normal" )
305 : {
306 0 : aModInfo.ModuleType = ModuleType::NORMAL;
307 : }
308 0 : else if( aMod.aModuleType == "class" )
309 : {
310 0 : aModInfo.ModuleType = ModuleType::CLASS;
311 : }
312 0 : else if( aMod.aModuleType == "form" )
313 : {
314 0 : aModInfo.ModuleType = ModuleType::FORM;
315 0 : aModInfo.ModuleObject = mxOwnerDocument;
316 : }
317 0 : else if( aMod.aModuleType == "document" )
318 : {
319 0 : aModInfo.ModuleType = ModuleType::DOCUMENT;
320 :
321 : // #163691# use the same codename access instance for all document modules
322 0 : if( !mxCodeNameAccess.is() ) try
323 : {
324 0 : Reference<frame::XModel > xModel( mxOwnerDocument );
325 0 : Reference< XMultiServiceFactory> xSF( xModel, UNO_QUERY_THROW );
326 0 : mxCodeNameAccess.set( xSF->createInstance("ooo.vba.VBAObjectModuleObjectProvider"), UNO_QUERY );
327 : }
328 0 : catch(const Exception& ) {}
329 :
330 0 : if( mxCodeNameAccess.is() )
331 : {
332 : try
333 : {
334 0 : aModInfo.ModuleObject.set( mxCodeNameAccess->getByName( aElementName), uno::UNO_QUERY );
335 : }
336 0 : catch(const uno::Exception&)
337 : {
338 : OSL_TRACE("Failed to get documument object for %s", OUStringToOString( aElementName, RTL_TEXTENCODING_UTF8 ).getStr() );
339 : }
340 : }
341 : }
342 :
343 0 : Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, UNO_QUERY );
344 0 : if( xVBAModuleInfo.is() )
345 : {
346 0 : if( xVBAModuleInfo->hasModuleInfo( aElementName ) )
347 : {
348 0 : xVBAModuleInfo->removeModuleInfo( aElementName );
349 : }
350 0 : xVBAModuleInfo->insertModuleInfo( aElementName, aModInfo );
351 0 : }
352 : }
353 :
354 72 : return aRetAny;
355 : }
356 :
357 0 : SfxLibraryContainer* SfxScriptLibraryContainer::createInstanceImpl()
358 : {
359 0 : return new SfxScriptLibraryContainer();
360 : }
361 :
362 0 : void SAL_CALL SfxScriptLibraryContainer::importFromOldStorage( const OUString& aFile )
363 : {
364 : // TODO: move loading from old storage to binary filters?
365 0 : tools::SvRef<SotStorage> xStorage = new SotStorage( false, aFile );
366 0 : if( xStorage.Is() && xStorage->GetError() == ERRCODE_NONE )
367 : {
368 0 : BasicManager* pBasicManager = new BasicManager( *static_cast<SotStorage*>(xStorage), aFile );
369 :
370 : // Set info
371 0 : LibraryContainerInfo aInfo( this, NULL, static_cast< OldBasicPassword* >( this ) );
372 0 : pBasicManager->SetLibraryContainerInfo( aInfo );
373 :
374 : // Now the libraries should be copied to this SfxScriptLibraryContainer
375 0 : BasicManager::LegacyDeleteBasicManager( pBasicManager );
376 0 : }
377 0 : }
378 :
379 :
380 : // Storing with password encryption
381 :
382 : // Methods XLibraryContainerPassword
383 56 : sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordProtected( const OUString& Name )
384 : throw (NoSuchElementException, RuntimeException, std::exception)
385 : {
386 56 : LibraryContainerMethodGuard aGuard( *this );
387 56 : SfxLibrary* pImplLib = getImplLib( Name );
388 56 : bool bRet = pImplLib->mbPasswordProtected;
389 56 : return bRet;
390 : }
391 :
392 0 : sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordVerified( const OUString& Name )
393 : throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
394 : {
395 0 : LibraryContainerMethodGuard aGuard( *this );
396 0 : SfxLibrary* pImplLib = getImplLib( Name );
397 0 : if( !pImplLib->mbPasswordProtected )
398 : {
399 0 : throw IllegalArgumentException();
400 : }
401 0 : bool bRet = pImplLib->mbPasswordVerified;
402 0 : return bRet;
403 : }
404 :
405 1 : sal_Bool SAL_CALL SfxScriptLibraryContainer::verifyLibraryPassword
406 : ( const OUString& Name, const OUString& Password )
407 : throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
408 : {
409 1 : LibraryContainerMethodGuard aGuard( *this );
410 1 : SfxLibrary* pImplLib = getImplLib( Name );
411 1 : if( !pImplLib->mbPasswordProtected || pImplLib->mbPasswordVerified )
412 : {
413 0 : throw IllegalArgumentException();
414 : }
415 : // Test password
416 1 : bool bSuccess = false;
417 1 : if( pImplLib->mbDoc50Password )
418 : {
419 0 : bSuccess = ( Password == pImplLib->maPassword );
420 0 : if( bSuccess )
421 : {
422 0 : pImplLib->mbPasswordVerified = true;
423 : }
424 : }
425 : else
426 : {
427 1 : pImplLib->maPassword = Password;
428 1 : bSuccess = implLoadPasswordLibrary( pImplLib, Name, true );
429 1 : if( bSuccess )
430 : {
431 : // The library gets modified by verifying the password, because other-
432 : // wise for saving the storage would be copied and that doesn't work
433 : // with mtg's storages when the password is verified
434 1 : pImplLib->implSetModified( true );
435 1 : pImplLib->mbPasswordVerified = true;
436 :
437 : // Reload library to get source
438 1 : if( pImplLib->mbLoaded )
439 : {
440 0 : implLoadPasswordLibrary( pImplLib, Name );
441 : }
442 : }
443 : }
444 1 : return bSuccess;
445 : }
446 :
447 0 : void SAL_CALL SfxScriptLibraryContainer::changeLibraryPassword( const OUString& Name,
448 : const OUString& OldPassword,
449 : const OUString& NewPassword )
450 : throw (IllegalArgumentException, NoSuchElementException, RuntimeException, std::exception)
451 : {
452 0 : LibraryContainerMethodGuard aGuard( *this );
453 0 : SfxLibrary* pImplLib = getImplLib( Name );
454 0 : if( OldPassword == NewPassword )
455 : {
456 0 : return;
457 : }
458 0 : bool bOldPassword = !OldPassword.isEmpty();
459 0 : bool bNewPassword = !NewPassword.isEmpty();
460 0 : bool bStorage = mxStorage.is() && !pImplLib->mbLink;
461 :
462 0 : if( pImplLib->mbReadOnly || (bOldPassword && !pImplLib->mbPasswordProtected) )
463 : {
464 0 : throw IllegalArgumentException();
465 : }
466 : // Library must be loaded
467 0 : loadLibrary( Name );
468 :
469 0 : bool bKillCryptedFiles = false;
470 0 : bool bKillUncryptedFiles = false;
471 :
472 : // Remove or change password?
473 0 : if( bOldPassword )
474 : {
475 0 : if( isLibraryPasswordVerified( Name ) )
476 : {
477 0 : if( pImplLib->maPassword != OldPassword )
478 : {
479 0 : throw IllegalArgumentException();
480 : }
481 : }
482 : else
483 : {
484 0 : if( !verifyLibraryPassword( Name, OldPassword ) )
485 : {
486 0 : throw IllegalArgumentException();
487 : }
488 : // Reload library to get source
489 : // Should be done in verifyLibraryPassword loadLibrary( Name );
490 : }
491 :
492 0 : if( !bNewPassword )
493 : {
494 0 : pImplLib->mbPasswordProtected = false;
495 0 : pImplLib->mbPasswordVerified = false;
496 0 : pImplLib->maPassword.clear();
497 :
498 0 : maModifiable.setModified( true );
499 0 : pImplLib->implSetModified( true );
500 :
501 0 : if( !bStorage && !pImplLib->mbDoc50Password )
502 : {
503 : // Store application basic uncrypted
504 0 : uno::Reference< embed::XStorage > xStorage;
505 0 : storeLibraries_Impl( xStorage, false );
506 0 : bKillCryptedFiles = true;
507 : }
508 : }
509 : }
510 :
511 : // Set new password?
512 0 : if( bNewPassword )
513 : {
514 0 : pImplLib->mbPasswordProtected = true;
515 0 : pImplLib->mbPasswordVerified = true;
516 0 : pImplLib->maPassword = NewPassword;
517 :
518 0 : maModifiable.setModified( true );
519 0 : pImplLib->implSetModified( true );
520 :
521 0 : if( !bStorage && !pImplLib->mbDoc50Password )
522 : {
523 : // Store application basic crypted
524 0 : uno::Reference< embed::XStorage > xStorage;
525 0 : storeLibraries_Impl( xStorage, false );
526 0 : bKillUncryptedFiles = true;
527 : }
528 : }
529 :
530 0 : if( bKillCryptedFiles || bKillUncryptedFiles )
531 : {
532 0 : Sequence< OUString > aElementNames = pImplLib->getElementNames();
533 0 : sal_Int32 nNameCount = aElementNames.getLength();
534 0 : const OUString* pNames = aElementNames.getConstArray();
535 0 : OUString aLibDirPath = createAppLibraryFolder( pImplLib, Name );
536 : try
537 : {
538 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
539 : {
540 0 : OUString aElementName = pNames[ i ];
541 :
542 0 : INetURLObject aElementInetObj( aLibDirPath );
543 : aElementInetObj.insertName( aElementName, false,
544 : INetURLObject::LAST_SEGMENT, true,
545 0 : INetURLObject::ENCODE_ALL );
546 0 : if( bKillUncryptedFiles )
547 : {
548 0 : aElementInetObj.setExtension( maLibElementFileExtension );
549 : }
550 : else
551 : {
552 0 : aElementInetObj.setExtension( OUString( "pba" ) );
553 : }
554 0 : OUString aElementPath( aElementInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
555 :
556 0 : if( mxSFI->exists( aElementPath ) )
557 : {
558 0 : mxSFI->kill( aElementPath );
559 : }
560 0 : }
561 : }
562 0 : catch(const Exception& ) {}
563 0 : }
564 : }
565 :
566 :
567 0 : void setStreamKey( uno::Reference< io::XStream > xStream, const OUString& aPass )
568 : {
569 0 : uno::Reference< embed::XEncryptionProtectedSource > xEncrStream( xStream, uno::UNO_QUERY );
570 0 : if ( xEncrStream.is() )
571 : {
572 0 : xEncrStream->setEncryptionPassword( aPass );
573 0 : }
574 0 : }
575 :
576 :
577 : // Impl methods
578 0 : bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib,
579 : const OUString& aName,
580 : const uno::Reference< embed::XStorage >& xStorage,
581 : const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
582 : {
583 0 : OUString aDummyLocation;
584 0 : Reference< XSimpleFileAccess3 > xDummySFA;
585 0 : return implStorePasswordLibrary( pLib, aName, xStorage, aDummyLocation, xDummySFA, xHandler );
586 : }
587 :
588 0 : bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName,
589 : const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage,
590 : const OUString& aTargetURL,
591 : const Reference< XSimpleFileAccess3 >& rToUseSFI,
592 : const ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionHandler >& xHandler )
593 : {
594 0 : bool bExport = !aTargetURL.isEmpty();
595 :
596 0 : BasicManager* pBasicMgr = getBasicManager();
597 : OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implStorePasswordLibrary: cannot do this without a BasicManager!" );
598 0 : if ( !pBasicMgr )
599 : {
600 0 : return false;
601 : }
602 : // Only need to handle the export case here,
603 : // save/saveas etc are handled in sfxbasemodel::storeSelf &
604 : // sfxbasemodel::impl_store
605 0 : uno::Sequence<OUString> aNames;
606 0 : if ( bExport && pBasicMgr->LegacyPsswdBinaryLimitExceeded(aNames) )
607 : {
608 0 : if ( xHandler.is() )
609 : {
610 0 : ModuleSizeExceeded* pReq = new ModuleSizeExceeded( aNames );
611 0 : uno::Reference< task::XInteractionRequest > xReq( pReq );
612 0 : xHandler->handle( xReq );
613 0 : if ( pReq->isAbort() )
614 : {
615 0 : throw util::VetoException();
616 0 : }
617 : }
618 : }
619 :
620 0 : StarBASIC* pBasicLib = pBasicMgr->GetLib( aName );
621 0 : if( !pBasicLib )
622 : {
623 0 : return false;
624 : }
625 0 : Sequence< OUString > aElementNames = pLib->getElementNames();
626 0 : sal_Int32 nNameCount = aElementNames.getLength();
627 0 : const OUString* pNames = aElementNames.getConstArray();
628 :
629 0 : bool bLink = pLib->mbLink;
630 0 : bool bStorage = xStorage.is() && !bLink;
631 0 : if( bStorage )
632 : {
633 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
634 : {
635 0 : OUString aElementName = pNames[ i ];
636 :
637 : // Write binary image stream
638 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
639 0 : if( pMod )
640 : {
641 0 : OUString aCodeStreamName = aElementName;
642 0 : aCodeStreamName += ".bin";
643 :
644 : try
645 : {
646 0 : uno::Reference< io::XStream > xCodeStream = xStorage->openStreamElement(
647 : aCodeStreamName,
648 0 : embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
649 :
650 0 : if ( !xCodeStream.is() )
651 : {
652 0 : throw uno::RuntimeException();
653 : }
654 0 : SvMemoryStream aMemStream;
655 0 : /*sal_Bool bStore = */pMod->StoreBinaryData( aMemStream );
656 :
657 0 : sal_Size nSize = aMemStream.Tell();
658 0 : Sequence< sal_Int8 > aBinSeq( nSize );
659 0 : sal_Int8* pData = aBinSeq.getArray();
660 0 : memcpy( pData, aMemStream.GetData(), nSize );
661 :
662 0 : Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
663 0 : if ( !xOut.is() )
664 : {
665 0 : throw io::IOException(); // access denied because the stream is readonly
666 : }
667 0 : xOut->writeBytes( aBinSeq );
668 0 : xOut->closeOutput();
669 : }
670 0 : catch(const uno::Exception& )
671 : {
672 : // TODO: handle error
673 0 : }
674 : }
675 :
676 0 : if( pLib->mbPasswordVerified || pLib->mbDoc50Password )
677 : {
678 0 : if( !isLibraryElementValid( pLib->getByName( aElementName ) ) )
679 : {
680 : #if OSL_DEBUG_LEVEL > 0
681 : OString aMessage = "invalid library element '" +
682 : OUStringToOString( aElementName, osl_getThreadTextEncoding() ) +
683 : "'.";
684 : OSL_FAIL( aMessage.getStr());
685 : #endif
686 0 : continue;
687 : }
688 :
689 0 : OUString aSourceStreamName = aElementName;
690 0 : aSourceStreamName += ".xml";
691 :
692 : try
693 : {
694 0 : uno::Reference< io::XStream > xSourceStream = xStorage->openStreamElement(
695 : aSourceStreamName,
696 0 : embed::ElementModes::READWRITE );
697 0 : uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
698 0 : if ( !xProps.is() )
699 : {
700 0 : throw uno::RuntimeException();
701 : }
702 0 : OUString aMime( "text/xml" );
703 0 : xProps->setPropertyValue("MediaType", uno::makeAny( aMime ) );
704 :
705 : // Set encryption key
706 0 : setStreamKey( xSourceStream, pLib->maPassword );
707 :
708 0 : Reference< XOutputStream > xOutput = xSourceStream->getOutputStream();
709 0 : Reference< XNameContainer > xLib( pLib );
710 0 : writeLibraryElement( xLib, aElementName, xOutput );
711 : }
712 0 : catch(const uno::Exception& )
713 : {
714 : OSL_FAIL( "Problem on storing of password library!\n" );
715 : // TODO: error handling
716 0 : }
717 : }
718 : else // !mbPasswordVerified
719 : {
720 : // TODO
721 : // What to do if not verified?! In any case it's already loaded here
722 : }
723 0 : }
724 :
725 : }
726 : // Application libraries have only to be saved if the password
727 : // is verified because otherwise they can't be modified
728 0 : else if( pLib->mbPasswordVerified || bExport )
729 : {
730 : try
731 : {
732 0 : Reference< XSimpleFileAccess3 > xSFI = mxSFI;
733 0 : if( rToUseSFI.is() )
734 : {
735 0 : xSFI = rToUseSFI;
736 : }
737 0 : OUString aLibDirPath;
738 0 : if( bExport )
739 : {
740 0 : INetURLObject aInetObj( aTargetURL );
741 : aInetObj.insertName( aName, true, INetURLObject::LAST_SEGMENT, true,
742 0 : INetURLObject::ENCODE_ALL );
743 0 : aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
744 :
745 0 : if( !xSFI->isFolder( aLibDirPath ) )
746 : {
747 0 : xSFI->createFolder( aLibDirPath );
748 0 : }
749 : }
750 : else
751 : {
752 0 : aLibDirPath = createAppLibraryFolder( pLib, aName );
753 : }
754 :
755 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
756 : {
757 0 : OUString aElementName = pNames[ i ];
758 :
759 0 : INetURLObject aElementInetObj( aLibDirPath );
760 : aElementInetObj.insertName( aElementName, false,
761 : INetURLObject::LAST_SEGMENT, true,
762 0 : INetURLObject::ENCODE_ALL );
763 0 : aElementInetObj.setExtension( OUString( "pba" ) );
764 0 : OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
765 :
766 0 : if( !isLibraryElementValid( pLib->getByName( aElementName ) ) )
767 : {
768 : #if OSL_DEBUG_LEVEL > 0
769 : OString aMessage = "invalid library element '" +
770 : OUStringToOString( aElementName, osl_getThreadTextEncoding() ) +
771 : "'.";
772 : OSL_FAIL( aMessage.getStr());
773 : #endif
774 0 : continue;
775 : }
776 :
777 : try
778 : {
779 : uno::Reference< embed::XStorage > xElementRootStorage =
780 : ::comphelper::OStorageHelper::GetStorageFromURL(
781 : aElementPath,
782 0 : embed::ElementModes::READWRITE );
783 0 : if ( !xElementRootStorage.is() )
784 : {
785 0 : throw uno::RuntimeException();
786 : }
787 : // Write binary image stream
788 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
789 0 : if( pMod )
790 : {
791 0 : OUString aCodeStreamName( "code.bin" );
792 :
793 0 : uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
794 : aCodeStreamName,
795 0 : embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
796 :
797 0 : SvMemoryStream aMemStream;
798 0 : /*sal_Bool bStore = */pMod->StoreBinaryData( aMemStream );
799 :
800 0 : sal_Size nSize = aMemStream.Tell();
801 0 : Sequence< sal_Int8 > aBinSeq( nSize );
802 0 : sal_Int8* pData = aBinSeq.getArray();
803 0 : memcpy( pData, aMemStream.GetData(), nSize );
804 :
805 0 : Reference< XOutputStream > xOut = xCodeStream->getOutputStream();
806 0 : if ( xOut.is() )
807 : {
808 0 : xOut->writeBytes( aBinSeq );
809 0 : xOut->closeOutput();
810 0 : }
811 : }
812 :
813 : // Write encrypted source stream
814 0 : OUString aSourceStreamName( "source.xml" );
815 :
816 0 : uno::Reference< io::XStream > xSourceStream;
817 : try
818 : {
819 0 : xSourceStream = xElementRootStorage->openStreamElement(
820 : aSourceStreamName,
821 0 : embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
822 :
823 : // #87671 Allow encryption
824 0 : uno::Reference< embed::XEncryptionProtectedSource > xEncr( xSourceStream, uno::UNO_QUERY );
825 : OSL_ENSURE( xEncr.is(),
826 : "StorageStream opened for writing must implement XEncryptionProtectedSource!\n" );
827 0 : if ( !xEncr.is() )
828 : {
829 0 : throw uno::RuntimeException();
830 : }
831 0 : xEncr->setEncryptionPassword( pLib->maPassword );
832 : }
833 0 : catch(const ::com::sun::star::packages::WrongPasswordException& )
834 : {
835 0 : xSourceStream = xElementRootStorage->openEncryptedStreamElement(
836 : aSourceStreamName,
837 : embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE,
838 0 : pLib->maPassword );
839 : }
840 :
841 0 : uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
842 0 : if ( !xProps.is() )
843 : {
844 0 : throw uno::RuntimeException();
845 : }
846 0 : OUString aMime( "text/xml" );
847 0 : xProps->setPropertyValue("MediaType", uno::makeAny( aMime ) );
848 :
849 0 : Reference< XOutputStream > xOut = xSourceStream->getOutputStream();
850 0 : Reference< XNameContainer > xLib( pLib );
851 0 : writeLibraryElement( xLib, aElementName, xOut );
852 : // i50568: sax writer already closes stream
853 : // xOut->closeOutput();
854 :
855 0 : uno::Reference< embed::XTransactedObject > xTransact( xElementRootStorage, uno::UNO_QUERY );
856 : OSL_ENSURE( xTransact.is(), "The storage must implement XTransactedObject!\n" );
857 0 : if ( !xTransact.is() )
858 : {
859 0 : throw uno::RuntimeException();
860 : }
861 :
862 0 : xTransact->commit();
863 : }
864 0 : catch(const uno::Exception& )
865 : {
866 : // TODO: handle error
867 : }
868 :
869 0 : }
870 : }
871 0 : catch(const Exception& )
872 : {
873 : }
874 : }
875 0 : return true;
876 : }
877 :
878 2 : bool SfxScriptLibraryContainer::implLoadPasswordLibrary
879 : ( SfxLibrary* pLib, const OUString& Name, bool bVerifyPasswordOnly )
880 : throw(WrappedTargetException, RuntimeException)
881 : {
882 2 : bool bRet = true;
883 :
884 2 : bool bLink = pLib->mbLink;
885 2 : bool bStorage = mxStorage.is() && !bLink;
886 :
887 : // Already loaded? Then only verifiedPassword can change something
888 2 : SfxScriptLibrary* pScriptLib = static_cast< SfxScriptLibrary* >( pLib );
889 2 : if( pScriptLib->mbLoaded )
890 : {
891 1 : if( pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly &&
892 0 : (pScriptLib->mbLoadedSource || !pLib->mbPasswordVerified) )
893 : {
894 0 : return false;
895 : }
896 : }
897 :
898 2 : StarBASIC* pBasicLib = NULL;
899 2 : bool bLoadBinary = false;
900 2 : if( !pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly && !pLib->mbPasswordVerified )
901 : {
902 0 : BasicManager* pBasicMgr = getBasicManager();
903 : OSL_ENSURE( pBasicMgr, "SfxScriptLibraryContainer::implLoadPasswordLibrary: cannot do this without a BasicManager!" );
904 0 : bool bLoaded = pScriptLib->mbLoaded;
905 0 : pScriptLib->mbLoaded = true; // Necessary to get lib
906 0 : pBasicLib = pBasicMgr ? pBasicMgr->GetLib( Name ) : NULL;
907 0 : pScriptLib->mbLoaded = bLoaded; // Restore flag
908 0 : if( !pBasicLib )
909 : {
910 0 : return false;
911 : }
912 0 : bLoadBinary = true;
913 0 : pScriptLib->mbLoadedBinary = true;
914 : }
915 :
916 2 : bool bLoadSource = false;
917 2 : if( !pScriptLib->mbLoadedSource && pLib->mbPasswordVerified && !bVerifyPasswordOnly )
918 : {
919 1 : bLoadSource = true;
920 1 : pScriptLib->mbLoadedSource = true;
921 : }
922 :
923 2 : Sequence< OUString > aElementNames = pLib->getElementNames();
924 2 : sal_Int32 nNameCount = aElementNames.getLength();
925 2 : const OUString* pNames = aElementNames.getConstArray();
926 :
927 2 : if( bStorage )
928 : {
929 2 : uno::Reference< embed::XStorage > xLibrariesStor;
930 4 : uno::Reference< embed::XStorage > xLibraryStor;
931 2 : if( bStorage )
932 : {
933 : try {
934 2 : xLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
935 2 : if ( !xLibrariesStor.is() )
936 : {
937 0 : throw uno::RuntimeException();
938 : }
939 2 : xLibraryStor = xLibrariesStor->openStorageElement( Name, embed::ElementModes::READ );
940 2 : if ( !xLibraryStor.is() )
941 : {
942 0 : throw uno::RuntimeException();
943 : }
944 : }
945 0 : catch(const uno::Exception& )
946 : {
947 : OSL_FAIL( "### couldn't open sub storage for library\n" );
948 0 : return false;
949 : }
950 : }
951 :
952 4 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
953 : {
954 2 : OUString aElementName = pNames[ i ];
955 :
956 : // Load binary
957 2 : if( bLoadBinary )
958 : {
959 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
960 0 : if( !pMod )
961 : {
962 0 : pMod = pBasicLib->MakeModule( aElementName, OUString() );
963 0 : pBasicLib->SetModified( false );
964 : }
965 :
966 0 : OUString aCodeStreamName= aElementName;
967 0 : aCodeStreamName += ".bin";
968 :
969 : try
970 : {
971 0 : uno::Reference< io::XStream > xCodeStream = xLibraryStor->openStreamElement(
972 : aCodeStreamName,
973 0 : embed::ElementModes::READ );
974 0 : if ( !xCodeStream.is() )
975 : {
976 0 : throw uno::RuntimeException();
977 : }
978 0 : boost::scoped_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream( xCodeStream ));
979 0 : if ( !pStream || pStream->GetError() )
980 : {
981 0 : sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
982 : throw task::ErrorCodeIOException(
983 : ("utl::UcbStreamHelper::CreateStream failed for \""
984 0 : + aCodeStreamName + "\": 0x"
985 0 : + OUString::number(nError, 16)),
986 0 : uno::Reference< uno::XInterface >(), nError);
987 : }
988 :
989 0 : /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
990 : // TODO: Check return value
991 : }
992 0 : catch(const uno::Exception& )
993 : {
994 : // TODO: error handling
995 0 : }
996 : }
997 :
998 : // Load source
999 2 : if( bLoadSource || bVerifyPasswordOnly )
1000 : {
1001 : // Access encrypted source stream
1002 2 : OUString aSourceStreamName = aElementName;
1003 2 : aSourceStreamName += ".xml";
1004 :
1005 : try
1006 : {
1007 2 : uno::Reference< io::XStream > xSourceStream = xLibraryStor->openEncryptedStreamElement(
1008 : aSourceStreamName,
1009 : embed::ElementModes::READ,
1010 2 : pLib->maPassword );
1011 2 : if ( !xSourceStream.is() )
1012 : {
1013 0 : throw uno::RuntimeException();
1014 : }
1015 : // if this point is reached then the password is correct
1016 2 : if ( !bVerifyPasswordOnly )
1017 : {
1018 1 : uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1019 1 : if ( !xInStream.is() )
1020 : {
1021 0 : throw io::IOException(); // read access denied, seems to be impossible
1022 : }
1023 2 : Reference< XNameContainer > xLib( pLib );
1024 : Any aAny = importLibraryElement( xLib,
1025 : aElementName, aSourceStreamName,
1026 2 : xInStream );
1027 1 : if( pLib->hasByName( aElementName ) )
1028 : {
1029 1 : if( aAny.hasValue() )
1030 : {
1031 1 : pLib->maNameContainer.replaceByName( aElementName, aAny );
1032 : }
1033 : }
1034 : else
1035 : {
1036 0 : pLib->maNameContainer.insertByName( aElementName, aAny );
1037 1 : }
1038 2 : }
1039 : }
1040 0 : catch(const uno::Exception& )
1041 : {
1042 0 : bRet = false;
1043 2 : }
1044 : }
1045 4 : }
1046 : }
1047 : else
1048 : {
1049 : try
1050 : {
1051 0 : OUString aLibDirPath = createAppLibraryFolder( pLib, Name );
1052 :
1053 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1054 : {
1055 0 : OUString aElementName = pNames[ i ];
1056 :
1057 0 : INetURLObject aElementInetObj( aLibDirPath );
1058 : aElementInetObj.insertName( aElementName, false,
1059 0 : INetURLObject::LAST_SEGMENT, true, INetURLObject::ENCODE_ALL );
1060 0 : aElementInetObj.setExtension( OUString( "pba" ) );
1061 0 : OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
1062 :
1063 0 : uno::Reference< embed::XStorage > xElementRootStorage;
1064 : try
1065 : {
1066 0 : xElementRootStorage = ::comphelper::OStorageHelper::GetStorageFromURL(
1067 : aElementPath,
1068 0 : embed::ElementModes::READ );
1069 0 : } catch(const uno::Exception& )
1070 : {
1071 : // TODO: error handling
1072 : }
1073 :
1074 0 : if ( xElementRootStorage.is() )
1075 : {
1076 : // Load binary
1077 0 : if( bLoadBinary )
1078 : {
1079 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
1080 0 : if( !pMod )
1081 : {
1082 0 : pMod = pBasicLib->MakeModule( aElementName, OUString() );
1083 0 : pBasicLib->SetModified( false );
1084 : }
1085 :
1086 : try
1087 : {
1088 0 : OUString aCodeStreamName( "code.bin" );
1089 0 : uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
1090 : aCodeStreamName,
1091 0 : embed::ElementModes::READ );
1092 :
1093 0 : boost::scoped_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream( xCodeStream ));
1094 0 : if ( !pStream || pStream->GetError() )
1095 : {
1096 0 : sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
1097 : throw task::ErrorCodeIOException(
1098 : ("utl::UcbStreamHelper::CreateStream failed"
1099 : " for code.bin: 0x"
1100 0 : + OUString::number(nError, 16)),
1101 : uno::Reference< uno::XInterface >(),
1102 0 : nError);
1103 : }
1104 :
1105 0 : /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
1106 : // TODO: Check return value
1107 : }
1108 0 : catch(const uno::Exception& )
1109 : {
1110 : // TODO: error handling
1111 : }
1112 : }
1113 :
1114 : // Load source
1115 0 : if( bLoadSource || bVerifyPasswordOnly )
1116 : {
1117 : // Access encrypted source stream
1118 0 : OUString aSourceStreamName( "source.xml" );
1119 : try
1120 : {
1121 0 : uno::Reference< io::XStream > xSourceStream = xElementRootStorage->openEncryptedStreamElement(
1122 : aSourceStreamName,
1123 : embed::ElementModes::READ,
1124 0 : pLib->maPassword );
1125 0 : if ( !xSourceStream.is() )
1126 : {
1127 0 : throw uno::RuntimeException();
1128 : }
1129 0 : if ( !bVerifyPasswordOnly )
1130 : {
1131 0 : uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1132 0 : if ( !xInStream.is() )
1133 : {
1134 0 : throw io::IOException(); // read access denied, seems to be impossible
1135 : }
1136 0 : Reference< XNameContainer > xLib( pLib );
1137 : Any aAny = importLibraryElement( xLib,
1138 : aElementName,
1139 : aSourceStreamName,
1140 0 : xInStream );
1141 0 : if( pLib->hasByName( aElementName ) )
1142 : {
1143 0 : if( aAny.hasValue() )
1144 : {
1145 0 : pLib->maNameContainer.replaceByName( aElementName, aAny );
1146 : }
1147 : }
1148 : else
1149 : {
1150 0 : pLib->maNameContainer.insertByName( aElementName, aAny );
1151 0 : }
1152 0 : }
1153 : }
1154 0 : catch (const uno::Exception& )
1155 : {
1156 0 : bRet = false;
1157 0 : }
1158 : }
1159 : }
1160 0 : }
1161 : }
1162 0 : catch(const Exception& )
1163 : {
1164 : // TODO
1165 : //throw e;
1166 : }
1167 : }
1168 :
1169 2 : return bRet;
1170 : }
1171 :
1172 :
1173 1212 : void SfxScriptLibraryContainer::onNewRootStorage()
1174 : {
1175 1212 : }
1176 :
1177 0 : sal_Bool SAL_CALL SfxScriptLibraryContainer:: HasExecutableCode( const OUString& Library )
1178 : throw (uno::RuntimeException, std::exception)
1179 : {
1180 0 : BasicManager* pBasicMgr = getBasicManager();
1181 : OSL_ENSURE( pBasicMgr, "we need a basicmanager, really we do" );
1182 0 : if ( pBasicMgr )
1183 : {
1184 0 : return pBasicMgr->HasExeCode( Library ); // need to change this to take name
1185 : }
1186 : // default to it has code if we can't decide
1187 0 : return sal_True;
1188 : }
1189 :
1190 :
1191 : // Service
1192 0 : OUString SAL_CALL SfxScriptLibraryContainer::getImplementationName( )
1193 : throw (RuntimeException, std::exception)
1194 : {
1195 0 : return OUString("com.sun.star.comp.sfx2.ScriptLibraryContainer" );
1196 : }
1197 :
1198 0 : Sequence< OUString > SAL_CALL SfxScriptLibraryContainer::getSupportedServiceNames( )
1199 : throw (RuntimeException, std::exception)
1200 : {
1201 0 : Sequence< OUString > aServiceNames( 2 );
1202 0 : aServiceNames[0] = "com.sun.star.script.DocumentScriptLibraryContainer";
1203 : // plus, for compatibility:
1204 0 : aServiceNames[1] = "com.sun.star.script.ScriptLibraryContainer";
1205 0 : return aServiceNames;
1206 : }
1207 :
1208 : // Implementation class SfxScriptLibrary
1209 :
1210 : // Ctor
1211 2106 : SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1212 : const Reference< XComponentContext >& xContext,
1213 : const Reference< XSimpleFileAccess3 >& xSFI )
1214 2106 : : SfxLibrary( _rModifiable, cppu::UnoType<OUString>::get(), xContext, xSFI )
1215 : , mbLoadedSource( false )
1216 2106 : , mbLoadedBinary( false )
1217 : {
1218 2106 : }
1219 :
1220 999 : SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1221 : const Reference< XComponentContext >& xContext,
1222 : const Reference< XSimpleFileAccess3 >& xSFI,
1223 : const OUString& aLibInfoFileURL,
1224 : const OUString& aStorageURL,
1225 : bool ReadOnly )
1226 999 : : SfxLibrary( _rModifiable, cppu::UnoType<OUString>::get(), xContext, xSFI,
1227 : aLibInfoFileURL, aStorageURL, ReadOnly)
1228 : , mbLoadedSource( false )
1229 1998 : , mbLoadedBinary( false )
1230 : {
1231 999 : }
1232 :
1233 3 : bool SfxScriptLibrary::isLoadedStorable()
1234 : {
1235 : // note: mbLoadedSource can only be true for password-protected lib!
1236 3 : return SfxLibrary::isLoadedStorable() && (!mbPasswordProtected || mbLoadedSource);
1237 : }
1238 :
1239 : // Provide modify state including resources
1240 0 : bool SfxScriptLibrary::isModified()
1241 : {
1242 0 : return implIsModified(); // No resources
1243 : }
1244 :
1245 0 : void SfxScriptLibrary::storeResources()
1246 : {
1247 : // No resources
1248 0 : }
1249 :
1250 0 : void SfxScriptLibrary::storeResourcesToURL( const OUString& URL,
1251 : const Reference< task::XInteractionHandler >& Handler )
1252 : {
1253 : (void)URL;
1254 : (void)Handler;
1255 0 : }
1256 :
1257 0 : void SfxScriptLibrary::storeResourcesAsURL
1258 : ( const OUString& URL, const OUString& NewName )
1259 : {
1260 : (void)URL;
1261 : (void)NewName;
1262 0 : }
1263 :
1264 2 : void SfxScriptLibrary::storeResourcesToStorage( const ::com::sun::star::uno::Reference
1265 : < ::com::sun::star::embed::XStorage >& xStorage )
1266 : {
1267 : // No resources
1268 : (void)xStorage;
1269 2 : }
1270 :
1271 1 : bool SfxScriptLibrary::containsValidModule(const Any& rElement)
1272 : {
1273 1 : OUString sModuleText;
1274 1 : rElement >>= sModuleText;
1275 1 : return ( !sModuleText.isEmpty() );
1276 : }
1277 :
1278 0 : bool SAL_CALL SfxScriptLibrary::isLibraryElementValid(const css::uno::Any& rElement) const
1279 : {
1280 0 : return SfxScriptLibrary::containsValidModule(rElement);
1281 : }
1282 :
1283 179782 : IMPLEMENT_FORWARD_XINTERFACE2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1284 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1285 :
1286 263 : script::ModuleInfo SAL_CALL SfxScriptLibrary::getModuleInfo( const OUString& ModuleName )
1287 : throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
1288 : {
1289 263 : if ( !hasModuleInfo( ModuleName ) )
1290 : {
1291 44 : throw NoSuchElementException();
1292 : }
1293 219 : return mModuleInfos[ ModuleName ];
1294 : }
1295 :
1296 657 : sal_Bool SAL_CALL SfxScriptLibrary::hasModuleInfo( const OUString& ModuleName )
1297 : throw (RuntimeException, std::exception)
1298 : {
1299 657 : bool bRes = false;
1300 657 : ModuleInfoMap::iterator it = mModuleInfos.find( ModuleName );
1301 :
1302 657 : if ( it != mModuleInfos.end() )
1303 : {
1304 381 : bRes = true;
1305 : }
1306 657 : return bRes;
1307 : }
1308 :
1309 162 : void SAL_CALL SfxScriptLibrary::insertModuleInfo( const OUString& ModuleName, const script::ModuleInfo& ModuleInfo )
1310 : throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException, std::exception)
1311 : {
1312 162 : if ( hasModuleInfo( ModuleName ) )
1313 : {
1314 0 : throw ElementExistException();
1315 : }
1316 162 : mModuleInfos[ ModuleName ] = ModuleInfo;
1317 162 : }
1318 :
1319 0 : void SAL_CALL SfxScriptLibrary::removeModuleInfo( const OUString& ModuleName )
1320 : throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
1321 : {
1322 : // #FIXME add NoSuchElementException to the spec
1323 0 : if ( !hasModuleInfo( ModuleName ) )
1324 : {
1325 0 : throw NoSuchElementException();
1326 : }
1327 0 : mModuleInfos.erase( mModuleInfos.find( ModuleName ) );
1328 0 : }
1329 :
1330 : } // namespace basic
1331 :
1332 :
1333 : extern "C" SAL_DLLPUBLIC_EXPORT ::com::sun::star::uno::XInterface* SAL_CALL
1334 3970 : com_sun_star_comp_sfx2_ScriptLibraryContainer_get_implementation(::com::sun::star::uno::XComponentContext*,
1335 : ::com::sun::star::uno::Sequence<css::uno::Any> const &)
1336 : {
1337 3970 : return cppu::acquire(new basic::SfxScriptLibraryContainer());
1338 : }
1339 :
1340 :
1341 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
