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