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 <com/sun/star/container/XNameContainer.hpp>
23 : #include <com/sun/star/xml/sax/Parser.hpp>
24 : #include <com/sun/star/xml/sax/InputSource.hpp>
25 : #include <com/sun/star/xml/sax/Writer.hpp>
26 : #include <com/sun/star/io/XOutputStream.hpp>
27 : #include <com/sun/star/io/XInputStream.hpp>
28 : #include <com/sun/star/io/XActiveDataSource.hpp>
29 : #include <com/sun/star/ucb/XSimpleFileAccess3.hpp>
30 : #include <com/sun/star/embed/ElementModes.hpp>
31 : #include <com/sun/star/embed/XEncryptionProtectedSource.hpp>
32 : #include <com/sun/star/beans/XPropertySet.hpp>
33 : #include <com/sun/star/embed/XTransactedObject.hpp>
34 : #include <com/sun/star/task/ErrorCodeIOException.hpp>
35 : #include <com/sun/star/script/ModuleType.hpp>
36 : #include <comphelper/componentcontext.hxx>
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 <rtl/digest.h>
43 : #include <rtl/strbuf.hxx>
44 :
45 : // For password functionality
46 : #include <tools/urlobj.hxx>
47 :
48 :
49 : #include <unotools/pathoptions.hxx>
50 : #include <svtools/sfxecode.hxx>
51 : #include <svtools/ehdl.hxx>
52 : #include <basic/basmgr.hxx>
53 : #include <basic/sbmod.hxx>
54 : #include <basic/basicmanagerrepository.hxx>
55 : #include "basic/modsizeexceeded.hxx"
56 : #include <xmlscript/xmlmod_imexp.hxx>
57 : #include <cppuhelper/factory.hxx>
58 : #include <com/sun/star/util/VetoException.hpp>
59 : #include <com/sun/star/script/XLibraryQueryExecutable.hpp>
60 : #include <cppuhelper/implbase1.hxx>
61 : namespace basic
62 : {
63 :
64 : using namespace com::sun::star::document;
65 : using namespace com::sun::star::container;
66 : using namespace com::sun::star::io;
67 : using namespace com::sun::star::uno;
68 : using namespace com::sun::star::ucb;
69 : using namespace com::sun::star::lang;
70 : using namespace com::sun::star::script;
71 : using namespace com::sun::star::xml::sax;
72 : using namespace com::sun::star;
73 : using namespace cppu;
74 : using namespace osl;
75 :
76 : //============================================================================
77 : // Implementation class SfxScriptLibraryContainer
78 :
79 422 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getInfoFileName() const { return "script"; }
80 422 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getOldInfoFileName() const { return "script"; }
81 422 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibElementFileExtension() const { return "xba"; }
82 422 : const sal_Char* SAL_CALL SfxScriptLibraryContainer::getLibrariesDir() const { return "Basic"; }
83 :
84 : // OldBasicPassword interface
85 0 : void SfxScriptLibraryContainer::setLibraryPassword( const OUString& rLibraryName, const OUString& rPassword )
86 : {
87 : try
88 : {
89 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
90 0 : if( !rPassword.isEmpty() )
91 : {
92 0 : pImplLib->mbDoc50Password = true;
93 0 : pImplLib->mbPasswordProtected = sal_True;
94 0 : pImplLib->maPassword = rPassword;
95 : }
96 : }
97 0 : catch(const NoSuchElementException& ) {}
98 0 : }
99 :
100 0 : OUString SfxScriptLibraryContainer::getLibraryPassword( const OUString& rLibraryName )
101 : {
102 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
103 0 : OUString aPassword;
104 0 : if( pImplLib->mbPasswordVerified )
105 : {
106 0 : aPassword = pImplLib->maPassword;
107 : }
108 0 : return aPassword;
109 : }
110 :
111 0 : void SfxScriptLibraryContainer::clearLibraryPassword( const OUString& rLibraryName )
112 : {
113 : try
114 : {
115 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
116 0 : pImplLib->mbDoc50Password = false;
117 0 : pImplLib->mbPasswordProtected = sal_False;
118 0 : pImplLib->maPassword = OUString();
119 : }
120 0 : catch(const NoSuchElementException& ) {}
121 0 : }
122 :
123 0 : sal_Bool SfxScriptLibraryContainer::hasLibraryPassword( const OUString& rLibraryName )
124 : {
125 0 : SfxLibrary* pImplLib = getImplLib( rLibraryName );
126 0 : return pImplLib->mbPasswordProtected;
127 : }
128 :
129 : // Ctor for service
130 511 : SfxScriptLibraryContainer::SfxScriptLibraryContainer( void )
131 511 : :maScriptLanguage( "StarBasic" )
132 : {
133 : // all initialisation has to be done
134 : // by calling XInitialization::initialize
135 511 : }
136 :
137 11 : SfxScriptLibraryContainer::SfxScriptLibraryContainer( const uno::Reference< embed::XStorage >& xStorage )
138 12 : :maScriptLanguage( "StarBasic" )
139 : {
140 12 : init( OUString(), xStorage );
141 10 : }
142 :
143 : // Methods to get library instances of the correct type
144 256 : SfxLibrary* SfxScriptLibraryContainer::implCreateLibrary( const OUString& aName )
145 : {
146 : (void)aName; // Only needed for SfxDialogLibrary
147 256 : SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxMSF, mxSFI );
148 256 : return pRet;
149 : }
150 :
151 0 : SfxLibrary* SfxScriptLibraryContainer::implCreateLibraryLink( const OUString& aName,
152 : const OUString& aLibInfoFileURL,
153 : const OUString& StorageURL,
154 : sal_Bool ReadOnly )
155 : {
156 : (void)aName; // Only needed for SfxDialogLibrary
157 : SfxLibrary* pRet = new SfxScriptLibrary( maModifiable, mxMSF, mxSFI,
158 0 : aLibInfoFileURL, StorageURL, ReadOnly );
159 0 : return pRet;
160 : }
161 :
162 0 : Any SAL_CALL SfxScriptLibraryContainer::createEmptyLibraryElement( void )
163 : {
164 0 : OUString aMod;
165 0 : Any aRetAny;
166 0 : aRetAny <<= aMod;
167 0 : return aRetAny;
168 : }
169 :
170 0 : bool SAL_CALL SfxScriptLibraryContainer::isLibraryElementValid( Any aElement ) const
171 : {
172 0 : return SfxScriptLibrary::containsValidModule( aElement );
173 : }
174 :
175 0 : void SAL_CALL SfxScriptLibraryContainer::writeLibraryElement( const Reference < XNameContainer >& xLib,
176 : const OUString& aElementName,
177 : const Reference< XOutputStream >& xOutput)
178 : throw(Exception)
179 : {
180 : // Create sax writer
181 0 : Reference< XWriter > xWriter = xml::sax::Writer::create(comphelper::getComponentContext(mxMSF));
182 :
183 0 : Reference< XTruncate > xTruncate( xOutput, UNO_QUERY );
184 : OSL_ENSURE( xTruncate.is(), "Currently only the streams that can be truncated are expected!" );
185 0 : if ( xTruncate.is() )
186 : {
187 0 : xTruncate->truncate();
188 : }
189 0 : xWriter->setOutputStream( xOutput );
190 :
191 0 : xmlscript::ModuleDescriptor aMod;
192 0 : aMod.aName = aElementName;
193 0 : aMod.aLanguage = maScriptLanguage;
194 0 : Any aElement = xLib->getByName( aElementName );
195 0 : aElement >>= aMod.aCode;
196 :
197 0 : Reference< script::vba::XVBAModuleInfo > xModInfo( xLib, UNO_QUERY );
198 0 : if( xModInfo.is() && xModInfo->hasModuleInfo( aElementName ) )
199 : {
200 0 : script::ModuleInfo aModInfo = xModInfo->getModuleInfo( aElementName );
201 0 : switch( aModInfo.ModuleType )
202 : {
203 : case ModuleType::NORMAL:
204 0 : aMod.aModuleType = "normal";
205 0 : break;
206 : case ModuleType::CLASS:
207 0 : aMod.aModuleType ="class";
208 0 : break;
209 : case ModuleType::FORM:
210 0 : aMod.aModuleType = "form";
211 0 : break;
212 : case ModuleType::DOCUMENT:
213 0 : aMod.aModuleType = "document";
214 0 : break;
215 : case ModuleType::UNKNOWN:
216 : // nothing
217 0 : break;
218 0 : }
219 : }
220 :
221 0 : xmlscript::exportScriptModule( xWriter, aMod );
222 0 : }
223 :
224 :
225 0 : Any SAL_CALL SfxScriptLibraryContainer::importLibraryElement
226 : ( const Reference < XNameContainer >& xLib,
227 : const OUString& aElementName, const OUString& aFile,
228 : const uno::Reference< io::XInputStream >& xInStream )
229 : {
230 0 : Any aRetAny;
231 :
232 0 : Reference< XParser > xParser = xml::sax::Parser::create( comphelper::getComponentContext(mxMSF) );
233 :
234 : // Read from storage?
235 0 : sal_Bool bStorage = xInStream.is();
236 0 : Reference< XInputStream > xInput;
237 :
238 0 : if( bStorage )
239 : {
240 0 : xInput = xInStream;
241 : }
242 : else
243 : {
244 : try
245 : {
246 0 : xInput = mxSFI->openFileRead( aFile );
247 : }
248 0 : catch(const Exception& )
249 : //catch( Exception& e )
250 : {
251 : // TODO:
252 : //throw WrappedTargetException( e );
253 : }
254 : }
255 :
256 0 : if( !xInput.is() )
257 : return aRetAny;
258 :
259 0 : InputSource source;
260 0 : source.aInputStream = xInput;
261 0 : source.sSystemId = aFile;
262 :
263 : // start parsing
264 0 : xmlscript::ModuleDescriptor aMod;
265 :
266 : try
267 : {
268 0 : xParser->setDocumentHandler( ::xmlscript::importScriptModule( aMod ) );
269 0 : xParser->parseStream( source );
270 : }
271 0 : catch(const Exception& )
272 : {
273 0 : SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFile );
274 0 : sal_uIntPtr nErrorCode = ERRCODE_IO_GENERAL;
275 0 : ErrorHandler::HandleError( nErrorCode );
276 : }
277 :
278 0 : aRetAny <<= aMod.aCode;
279 :
280 : // TODO: Check language
281 : // aMod.aLanguage
282 : // aMod.aName ignored
283 0 : 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( OUString( "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( rtl::OUString("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", rtl::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 0 : return aRetAny;
355 : }
356 :
357 0 : SfxLibraryContainer* SfxScriptLibraryContainer::createInstanceImpl( void )
358 : {
359 0 : return new SfxScriptLibraryContainer();
360 : }
361 :
362 0 : void SAL_CALL SfxScriptLibraryContainer::importFromOldStorage( const ::rtl::OUString& aFile )
363 : {
364 : // TODO: move loading from old storage to binary filters?
365 0 : SotStorageRef xStorage = new SotStorage( sal_False, aFile );
366 0 : if( xStorage.Is() && xStorage->GetError() == ERRCODE_NONE )
367 : {
368 0 : BasicManager* pBasicManager = new BasicManager( *(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 2 : sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordProtected( const OUString& Name )
384 : throw (NoSuchElementException, RuntimeException)
385 : {
386 2 : LibraryContainerMethodGuard aGuard( *this );
387 2 : SfxLibrary* pImplLib = getImplLib( Name );
388 2 : sal_Bool bRet = pImplLib->mbPasswordProtected;
389 2 : return bRet;
390 : }
391 :
392 0 : sal_Bool SAL_CALL SfxScriptLibraryContainer::isLibraryPasswordVerified( const OUString& Name )
393 : throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
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 : sal_Bool bRet = pImplLib->mbPasswordVerified;
402 0 : return bRet;
403 : }
404 :
405 0 : sal_Bool SAL_CALL SfxScriptLibraryContainer::verifyLibraryPassword
406 : ( const OUString& Name, const OUString& Password )
407 : throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
408 : {
409 0 : LibraryContainerMethodGuard aGuard( *this );
410 0 : SfxLibrary* pImplLib = getImplLib( Name );
411 0 : if( !pImplLib->mbPasswordProtected || pImplLib->mbPasswordVerified )
412 : {
413 0 : throw IllegalArgumentException();
414 : }
415 : // Test password
416 0 : sal_Bool bSuccess = sal_False;
417 0 : if( pImplLib->mbDoc50Password )
418 : {
419 0 : bSuccess = ( Password == pImplLib->maPassword );
420 0 : if( bSuccess )
421 : {
422 0 : pImplLib->mbPasswordVerified = sal_True;
423 : }
424 : }
425 : else
426 : {
427 0 : pImplLib->maPassword = Password;
428 0 : bSuccess = implLoadPasswordLibrary( pImplLib, Name, sal_True );
429 0 : if( bSuccess )
430 : {
431 : // The library gets modified by verifiying 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 0 : pImplLib->implSetModified( sal_True );
435 0 : pImplLib->mbPasswordVerified = sal_True;
436 :
437 : // Reload library to get source
438 0 : if( pImplLib->mbLoaded )
439 : {
440 0 : implLoadPasswordLibrary( pImplLib, Name );
441 : }
442 : }
443 : }
444 0 : 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)
451 : {
452 0 : LibraryContainerMethodGuard aGuard( *this );
453 0 : SfxLibrary* pImplLib = getImplLib( Name );
454 0 : if( OldPassword == NewPassword )
455 : {
456 0 : return;
457 : }
458 0 : sal_Bool bOldPassword = !OldPassword.isEmpty();
459 0 : sal_Bool bNewPassword = !NewPassword.isEmpty();
460 0 : sal_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 : sal_Bool bKillCryptedFiles = sal_False;
470 0 : sal_Bool bKillUncryptedFiles = sal_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 = sal_False;
495 0 : pImplLib->mbPasswordVerified = sal_False;
496 0 : pImplLib->maPassword = OUString();
497 :
498 0 : maModifiable.setModified( sal_True );
499 0 : pImplLib->implSetModified( sal_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 = sal_True;
507 : }
508 : }
509 : }
510 :
511 : // Set new password?
512 0 : if( bNewPassword )
513 : {
514 0 : pImplLib->mbPasswordProtected = sal_True;
515 0 : pImplLib->mbPasswordVerified = sal_True;
516 0 : pImplLib->maPassword = NewPassword;
517 :
518 0 : maModifiable.setModified( sal_True );
519 0 : pImplLib->implSetModified( sal_True );
520 :
521 0 : if( !bStorage && !pImplLib->mbDoc50Password )
522 : {
523 : // Store applictaion basic crypted
524 0 : uno::Reference< embed::XStorage > xStorage;
525 0 : storeLibraries_Impl( xStorage, false );
526 0 : bKillUncryptedFiles = sal_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, sal_False,
544 : INetURLObject::LAST_SEGMENT, sal_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 ::rtl::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 : sal_Bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib,
579 : const ::rtl::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 : sal_Bool SfxScriptLibraryContainer::implStorePasswordLibrary( SfxLibrary* pLib, const ::rtl::OUString& aName,
589 : const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage,
590 : const ::rtl::OUString& aTargetURL,
591 : const Reference< XSimpleFileAccess3 > xToUseSFI,
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 sal_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<rtl::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 sal_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 : sal_Bool bLink = pLib->mbLink;
630 0 : sal_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_Int32 nSize = (sal_Int32)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 : ::rtl::OStringBuffer aMessage;
682 : aMessage.append( "invalid library element '" );
683 : aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
684 : aMessage.append( "'." );
685 : OSL_FAIL( aMessage.makeStringAndClear().getStr() );
686 : #endif
687 0 : continue;
688 : }
689 :
690 0 : OUString aSourceStreamName = aElementName;
691 0 : aSourceStreamName += ".xml";
692 :
693 : try
694 : {
695 0 : uno::Reference< io::XStream > xSourceStream = xStorage->openStreamElement(
696 : aSourceStreamName,
697 0 : embed::ElementModes::READWRITE );
698 0 : uno::Reference< beans::XPropertySet > xProps( xSourceStream, uno::UNO_QUERY );
699 0 : if ( !xProps.is() )
700 : {
701 0 : throw uno::RuntimeException();
702 : }
703 0 : OUString aMime( "text/xml" );
704 0 : xProps->setPropertyValue( rtl::OUString("MediaType"), uno::makeAny( aMime ) );
705 :
706 : // Set encryption key
707 0 : setStreamKey( xSourceStream, pLib->maPassword );
708 :
709 0 : Reference< XOutputStream > xOutput = xSourceStream->getOutputStream();
710 0 : Reference< XNameContainer > xLib( pLib );
711 0 : writeLibraryElement( xLib, aElementName, xOutput );
712 : }
713 0 : catch(const uno::Exception& )
714 : {
715 : OSL_FAIL( "Problem on storing of password library!\n" );
716 : // TODO: error handling
717 0 : }
718 : }
719 : else // !mbPasswordVerified
720 : {
721 : // TODO
722 : // What to do if not verified?! In any case it's already loaded here
723 : }
724 0 : }
725 :
726 : }
727 : // Application libraries have only to be saved if the password
728 : // is verified because otherwise they can't be modified
729 0 : else if( pLib->mbPasswordVerified || bExport )
730 : {
731 : try
732 : {
733 0 : Reference< XSimpleFileAccess3 > xSFI = mxSFI;
734 0 : if( xToUseSFI.is() )
735 : {
736 0 : xSFI = xToUseSFI;
737 : }
738 0 : OUString aLibDirPath;
739 0 : if( bExport )
740 : {
741 0 : INetURLObject aInetObj( aTargetURL );
742 : aInetObj.insertName( aName, sal_True, INetURLObject::LAST_SEGMENT, sal_True,
743 0 : INetURLObject::ENCODE_ALL );
744 0 : aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
745 :
746 0 : if( !xSFI->isFolder( aLibDirPath ) )
747 : {
748 0 : xSFI->createFolder( aLibDirPath );
749 0 : }
750 : }
751 : else
752 : {
753 0 : aLibDirPath = createAppLibraryFolder( pLib, aName );
754 : }
755 :
756 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
757 : {
758 0 : OUString aElementName = pNames[ i ];
759 :
760 0 : INetURLObject aElementInetObj( aLibDirPath );
761 : aElementInetObj.insertName( aElementName, sal_False,
762 : INetURLObject::LAST_SEGMENT, sal_True,
763 0 : INetURLObject::ENCODE_ALL );
764 0 : aElementInetObj.setExtension( OUString( "pba" ) );
765 0 : OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
766 :
767 0 : if( !isLibraryElementValid( pLib->getByName( aElementName ) ) )
768 : {
769 : #if OSL_DEBUG_LEVEL > 0
770 : ::rtl::OStringBuffer aMessage;
771 : aMessage.append( "invalid library element '" );
772 : aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
773 : aMessage.append( "'." );
774 : OSL_FAIL( aMessage.makeStringAndClear().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_Int32 nSize = (sal_Int32)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( rtl::OUString("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 sal_True;
878 : }
879 :
880 0 : sal_Bool SfxScriptLibraryContainer::implLoadPasswordLibrary
881 : ( SfxLibrary* pLib, const OUString& Name, sal_Bool bVerifyPasswordOnly )
882 : throw(WrappedTargetException, RuntimeException)
883 : {
884 0 : sal_Bool bRet = sal_True;
885 :
886 0 : sal_Bool bLink = pLib->mbLink;
887 0 : sal_Bool bStorage = mxStorage.is() && !bLink;
888 :
889 : // Already loaded? Then only verifiedPassword can change something
890 0 : SfxScriptLibrary* pScriptLib = static_cast< SfxScriptLibrary* >( pLib );
891 0 : if( pScriptLib->mbLoaded )
892 : {
893 0 : if( pScriptLib->mbLoadedBinary && !bVerifyPasswordOnly &&
894 0 : (pScriptLib->mbLoadedSource || !pLib->mbPasswordVerified) )
895 : {
896 0 : return sal_False;
897 : }
898 : }
899 :
900 0 : StarBASIC* pBasicLib = NULL;
901 0 : sal_Bool bLoadBinary = sal_False;
902 0 : 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 : sal_Bool bLoaded = pScriptLib->mbLoaded;
907 0 : pScriptLib->mbLoaded = sal_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 sal_False;
913 : }
914 0 : bLoadBinary = sal_True;
915 0 : pScriptLib->mbLoadedBinary = true;
916 : }
917 :
918 0 : sal_Bool bLoadSource = sal_False;
919 0 : if( !pScriptLib->mbLoadedSource && pLib->mbPasswordVerified && !bVerifyPasswordOnly )
920 : {
921 0 : bLoadSource = sal_True;
922 0 : pScriptLib->mbLoadedSource = true;
923 : }
924 :
925 0 : Sequence< OUString > aElementNames = pLib->getElementNames();
926 0 : sal_Int32 nNameCount = aElementNames.getLength();
927 0 : const OUString* pNames = aElementNames.getConstArray();
928 :
929 0 : if( bStorage )
930 : {
931 0 : uno::Reference< embed::XStorage > xLibrariesStor;
932 0 : uno::Reference< embed::XStorage > xLibraryStor;
933 0 : if( bStorage )
934 : {
935 : try {
936 0 : xLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
937 0 : if ( !xLibrariesStor.is() )
938 : {
939 0 : throw uno::RuntimeException();
940 : }
941 0 : xLibraryStor = xLibrariesStor->openStorageElement( Name, embed::ElementModes::READ );
942 0 : 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 sal_False;
951 : }
952 : }
953 :
954 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
955 : {
956 0 : OUString aElementName = pNames[ i ];
957 :
958 : // Load binary
959 0 : if( bLoadBinary )
960 : {
961 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
962 0 : if( !pMod )
963 : {
964 0 : pMod = pBasicLib->MakeModule( aElementName, String() );
965 0 : pBasicLib->SetModified( sal_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 : 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 0 : delete pStream;
985 0 : throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), nError );
986 : }
987 :
988 0 : /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
989 : // TODO: Check return value
990 :
991 0 : delete pStream;
992 : }
993 0 : catch(const uno::Exception& )
994 : {
995 : // TODO: error handling
996 0 : }
997 : }
998 :
999 : // Load source
1000 0 : if( bLoadSource || bVerifyPasswordOnly )
1001 : {
1002 : // Access encrypted source stream
1003 0 : OUString aSourceStreamName = aElementName;
1004 0 : aSourceStreamName += ".xml";
1005 :
1006 : try
1007 : {
1008 0 : uno::Reference< io::XStream > xSourceStream = xLibraryStor->openEncryptedStreamElement(
1009 : aSourceStreamName,
1010 : embed::ElementModes::READ,
1011 0 : pLib->maPassword );
1012 0 : if ( !xSourceStream.is() )
1013 : {
1014 0 : throw uno::RuntimeException();
1015 : }
1016 : // if this point is reached then the password is correct
1017 0 : if ( !bVerifyPasswordOnly )
1018 : {
1019 0 : uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1020 0 : if ( !xInStream.is() )
1021 : {
1022 0 : throw io::IOException(); // read access denied, seems to be impossible
1023 : }
1024 0 : Reference< XNameContainer > xLib( pLib );
1025 : Any aAny = importLibraryElement( xLib,
1026 : aElementName, aSourceStreamName,
1027 0 : xInStream );
1028 0 : if( pLib->hasByName( aElementName ) )
1029 : {
1030 0 : if( aAny.hasValue() )
1031 : {
1032 0 : pLib->maNameContainer.replaceByName( aElementName, aAny );
1033 : }
1034 : }
1035 : else
1036 : {
1037 0 : pLib->maNameContainer.insertByName( aElementName, aAny );
1038 0 : }
1039 0 : }
1040 : }
1041 0 : catch(const uno::Exception& )
1042 : {
1043 0 : bRet = sal_False;
1044 0 : }
1045 : }
1046 0 : }
1047 : }
1048 : else
1049 : {
1050 : try
1051 : {
1052 0 : OUString aLibDirPath = createAppLibraryFolder( pLib, Name );
1053 :
1054 0 : for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1055 : {
1056 0 : OUString aElementName = pNames[ i ];
1057 :
1058 0 : INetURLObject aElementInetObj( aLibDirPath );
1059 : aElementInetObj.insertName( aElementName, sal_False,
1060 0 : INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1061 0 : aElementInetObj.setExtension( OUString( "pba" ) );
1062 0 : OUString aElementPath = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
1063 :
1064 0 : uno::Reference< embed::XStorage > xElementRootStorage;
1065 : try
1066 : {
1067 : xElementRootStorage = ::comphelper::OStorageHelper::GetStorageFromURL(
1068 : aElementPath,
1069 0 : embed::ElementModes::READ );
1070 0 : } catch(const uno::Exception& )
1071 : {
1072 : // TODO: error handling
1073 : }
1074 :
1075 0 : if ( xElementRootStorage.is() )
1076 : {
1077 : // Load binary
1078 0 : if( bLoadBinary )
1079 : {
1080 0 : SbModule* pMod = pBasicLib->FindModule( aElementName );
1081 0 : if( !pMod )
1082 : {
1083 0 : pMod = pBasicLib->MakeModule( aElementName, String() );
1084 0 : pBasicLib->SetModified( sal_False );
1085 : }
1086 :
1087 : try
1088 : {
1089 0 : OUString aCodeStreamName( "code.bin" );
1090 0 : uno::Reference< io::XStream > xCodeStream = xElementRootStorage->openStreamElement(
1091 : aCodeStreamName,
1092 0 : embed::ElementModes::READ );
1093 :
1094 0 : SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( xCodeStream );
1095 0 : if ( !pStream || pStream->GetError() )
1096 : {
1097 0 : sal_Int32 nError = pStream ? pStream->GetError() : ERRCODE_IO_GENERAL;
1098 0 : delete pStream;
1099 : throw task::ErrorCodeIOException( ::rtl::OUString(),
1100 : uno::Reference< uno::XInterface >(),
1101 0 : nError );
1102 : }
1103 :
1104 0 : /*sal_Bool bRet = */pMod->LoadBinaryData( *pStream );
1105 : // TODO: Check return value
1106 :
1107 0 : delete pStream;
1108 : }
1109 0 : catch(const uno::Exception& )
1110 : {
1111 : // TODO: error handling
1112 : }
1113 : }
1114 :
1115 : // Load source
1116 0 : if( bLoadSource || bVerifyPasswordOnly )
1117 : {
1118 : // Access encrypted source stream
1119 0 : OUString aSourceStreamName( "source.xml" );
1120 : try
1121 : {
1122 0 : uno::Reference< io::XStream > xSourceStream = xElementRootStorage->openEncryptedStreamElement(
1123 : aSourceStreamName,
1124 : embed::ElementModes::READ,
1125 0 : pLib->maPassword );
1126 0 : if ( !xSourceStream.is() )
1127 : {
1128 0 : throw uno::RuntimeException();
1129 : }
1130 0 : if ( !bVerifyPasswordOnly )
1131 : {
1132 0 : uno::Reference< io::XInputStream > xInStream = xSourceStream->getInputStream();
1133 0 : if ( !xInStream.is() )
1134 : {
1135 0 : throw io::IOException(); // read access denied, seems to be impossible
1136 : }
1137 0 : Reference< XNameContainer > xLib( pLib );
1138 : Any aAny = importLibraryElement( xLib,
1139 : aElementName,
1140 : aSourceStreamName,
1141 0 : xInStream );
1142 0 : if( pLib->hasByName( aElementName ) )
1143 : {
1144 0 : if( aAny.hasValue() )
1145 : {
1146 0 : pLib->maNameContainer.replaceByName( aElementName, aAny );
1147 : }
1148 : }
1149 : else
1150 : {
1151 0 : pLib->maNameContainer.insertByName( aElementName, aAny );
1152 0 : }
1153 0 : }
1154 : }
1155 0 : catch (const uno::Exception& )
1156 : {
1157 0 : bRet = sal_False;
1158 0 : }
1159 : }
1160 : }
1161 0 : }
1162 : }
1163 0 : catch(const Exception& )
1164 : {
1165 : // TODO
1166 : //throw e;
1167 : }
1168 : }
1169 :
1170 0 : return bRet;
1171 : }
1172 :
1173 :
1174 573 : void SfxScriptLibraryContainer::onNewRootStorage()
1175 : {
1176 573 : }
1177 :
1178 0 : sal_Bool SAL_CALL SfxScriptLibraryContainer:: HasExecutableCode( const ::rtl::OUString& Library )
1179 : throw (uno::RuntimeException)
1180 : {
1181 0 : BasicManager* pBasicMgr = getBasicManager();
1182 : OSL_ENSURE( pBasicMgr, "we need a basicmanager, really we do" );
1183 0 : if ( pBasicMgr )
1184 : {
1185 0 : return pBasicMgr->HasExeCode( Library ); // need to change this to take name
1186 : }
1187 : // default to it has code if we can't decide
1188 0 : return sal_True;
1189 : }
1190 :
1191 : //============================================================================
1192 : // Service
1193 19 : void createRegistryInfo_SfxScriptLibraryContainer()
1194 : {
1195 19 : static OAutoRegistration< SfxScriptLibraryContainer > aAutoRegistration;
1196 19 : }
1197 :
1198 0 : OUString SAL_CALL SfxScriptLibraryContainer::getImplementationName( )
1199 : throw (RuntimeException)
1200 : {
1201 0 : return getImplementationName_static();
1202 : }
1203 :
1204 0 : Sequence< OUString > SAL_CALL SfxScriptLibraryContainer::getSupportedServiceNames( )
1205 : throw (RuntimeException)
1206 : {
1207 0 : return getSupportedServiceNames_static();
1208 : }
1209 :
1210 12 : Sequence< OUString > SfxScriptLibraryContainer::getSupportedServiceNames_static()
1211 : {
1212 12 : Sequence< OUString > aServiceNames( 2 );
1213 12 : aServiceNames[0] = OUString("com.sun.star.script.DocumentScriptLibraryContainer" );
1214 : // plus, for compatibility:
1215 12 : aServiceNames[1] = OUString("com.sun.star.script.ScriptLibraryContainer" );
1216 12 : return aServiceNames;
1217 : }
1218 :
1219 12 : OUString SfxScriptLibraryContainer::getImplementationName_static()
1220 : {
1221 12 : return OUString("com.sun.star.comp.sfx2.ScriptLibraryContainer" );
1222 : }
1223 :
1224 511 : Reference< XInterface > SAL_CALL SfxScriptLibraryContainer::Create( const Reference< XComponentContext >& )
1225 : throw( Exception )
1226 : {
1227 511 : Reference< XInterface > xRet = static_cast< XInterface* >( static_cast< OWeakObject* >(new SfxScriptLibraryContainer()) );
1228 511 : return xRet;
1229 : }
1230 :
1231 : //============================================================================
1232 : // Implementation class SfxScriptLibrary
1233 :
1234 : // Ctor
1235 256 : SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1236 : const Reference< XMultiServiceFactory >& xMSF,
1237 : const Reference< XSimpleFileAccess3 >& xSFI )
1238 256 : : SfxLibrary( _rModifiable, getCppuType( (const OUString *)0 ), xMSF, xSFI )
1239 : , mbLoadedSource( false )
1240 256 : , mbLoadedBinary( false )
1241 : {
1242 256 : }
1243 :
1244 0 : SfxScriptLibrary::SfxScriptLibrary( ModifiableHelper& _rModifiable,
1245 : const Reference< XMultiServiceFactory >& xMSF,
1246 : const Reference< XSimpleFileAccess3 >& xSFI,
1247 : const OUString& aLibInfoFileURL,
1248 : const OUString& aStorageURL,
1249 : sal_Bool ReadOnly )
1250 0 : : SfxLibrary( _rModifiable, getCppuType( (const OUString *)0 ), xMSF, xSFI,
1251 : aLibInfoFileURL, aStorageURL, ReadOnly)
1252 : , mbLoadedSource( false )
1253 0 : , mbLoadedBinary( false )
1254 : {
1255 0 : }
1256 :
1257 : // Provide modify state including resources
1258 0 : sal_Bool SfxScriptLibrary::isModified( void )
1259 : {
1260 0 : return implIsModified(); // No resources
1261 : }
1262 :
1263 0 : void SfxScriptLibrary::storeResources( void )
1264 : {
1265 : // No resources
1266 0 : }
1267 :
1268 0 : void SfxScriptLibrary::storeResourcesToURL( const ::rtl::OUString& URL,
1269 : const Reference< task::XInteractionHandler >& Handler )
1270 : {
1271 : (void)URL;
1272 : (void)Handler;
1273 0 : }
1274 :
1275 0 : void SfxScriptLibrary::storeResourcesAsURL
1276 : ( const ::rtl::OUString& URL, const ::rtl::OUString& NewName )
1277 : {
1278 : (void)URL;
1279 : (void)NewName;
1280 0 : }
1281 :
1282 0 : void SfxScriptLibrary::storeResourcesToStorage( const ::com::sun::star::uno::Reference
1283 : < ::com::sun::star::embed::XStorage >& xStorage )
1284 : {
1285 : // No resources
1286 : (void)xStorage;
1287 0 : }
1288 :
1289 0 : bool SfxScriptLibrary::containsValidModule( const Any& aElement )
1290 : {
1291 0 : OUString sModuleText;
1292 0 : aElement >>= sModuleText;
1293 0 : return ( !sModuleText.isEmpty() );
1294 : }
1295 :
1296 0 : bool SAL_CALL SfxScriptLibrary::isLibraryElementValid( ::com::sun::star::uno::Any aElement ) const
1297 : {
1298 0 : return SfxScriptLibrary::containsValidModule( aElement );
1299 : }
1300 :
1301 13639 : IMPLEMENT_FORWARD_XINTERFACE2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1302 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( SfxScriptLibrary, SfxLibrary, SfxScriptLibrary_BASE );
1303 :
1304 15 : script::ModuleInfo SAL_CALL SfxScriptLibrary::getModuleInfo( const OUString& ModuleName )
1305 : throw (NoSuchElementException, WrappedTargetException, RuntimeException)
1306 : {
1307 15 : if ( !hasModuleInfo( ModuleName ) )
1308 : {
1309 0 : throw NoSuchElementException();
1310 : }
1311 15 : return mModuleInfos[ ModuleName ];
1312 : }
1313 :
1314 45 : sal_Bool SAL_CALL SfxScriptLibrary::hasModuleInfo( const OUString& ModuleName )
1315 : throw (RuntimeException)
1316 : {
1317 45 : sal_Bool bRes = sal_False;
1318 45 : ModuleInfoMap::iterator it = mModuleInfos.find( ModuleName );
1319 :
1320 45 : if ( it != mModuleInfos.end() )
1321 : {
1322 30 : bRes = sal_True;
1323 : }
1324 45 : return bRes;
1325 : }
1326 :
1327 15 : void SAL_CALL SfxScriptLibrary::insertModuleInfo( const OUString& ModuleName, const script::ModuleInfo& ModuleInfo )
1328 : throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
1329 : {
1330 15 : if ( hasModuleInfo( ModuleName ) )
1331 : {
1332 0 : throw ElementExistException();
1333 : }
1334 15 : mModuleInfos[ ModuleName ] = ModuleInfo;
1335 15 : }
1336 :
1337 0 : void SAL_CALL SfxScriptLibrary::removeModuleInfo( const OUString& ModuleName )
1338 : throw (NoSuchElementException, WrappedTargetException, RuntimeException)
1339 : {
1340 : // #FIXME add NoSuchElementException to the spec
1341 0 : if ( !hasModuleInfo( ModuleName ) )
1342 : {
1343 0 : throw NoSuchElementException();
1344 : }
1345 0 : mModuleInfos.erase( mModuleInfos.find( ModuleName ) );
1346 0 : }
1347 :
1348 :
1349 : //============================================================================
1350 :
1351 : } // namespace basic
1352 :
1353 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
