LibreOffice Module ucb (master)  1
ftpcontent.cxx
Go to the documentation of this file.
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 
21 /**************************************************************************
22  TODO
23  **************************************************************************
24 
25  *************************************************************************/
26 #include <com/sun/star/beans/PropertyAttribute.hpp>
27 
28 #include "ftpdynresultset.hxx"
29 #include "ftpresultsetfactory.hxx"
30 #include "ftpresultsetI.hxx"
31 #include "ftpcontent.hxx"
32 #include "ftpcontentprovider.hxx"
33 #include "ftpdirp.hxx"
34 #include "ftpcontentidentifier.hxx"
35 #include "ftpintreq.hxx"
36 
37 #include <memory>
38 #include <vector>
39 #include <string.h>
40 #include "curl.hxx"
49 #include <com/sun/star/lang/IllegalAccessException.hpp>
50 #include <com/sun/star/lang/NoSupportException.hpp>
51 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
52 #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
53 #include <com/sun/star/beans/IllegalTypeException.hpp>
54 #include <com/sun/star/beans/UnknownPropertyException.hpp>
55 #include <com/sun/star/beans/Property.hpp>
56 #include <com/sun/star/ucb/XCommandInfo.hpp>
57 #include <com/sun/star/io/BufferSizeExceededException.hpp>
58 #include <com/sun/star/io/IOException.hpp>
59 #include <com/sun/star/io/NotConnectedException.hpp>
60 #include <com/sun/star/io/XActiveDataSink.hpp>
61 #include <com/sun/star/io/XOutputStream.hpp>
62 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
63 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
64 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
65 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
66 #include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp>
67 #include <com/sun/star/ucb/InteractiveIOException.hpp>
68 #include <com/sun/star/ucb/MissingPropertiesException.hpp>
69 #include <com/sun/star/ucb/MissingInputStreamException.hpp>
70 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
71 #include <com/sun/star/ucb/OpenMode.hpp>
72 #include <com/sun/star/ucb/IOErrorCode.hpp>
73 
74 using namespace ftp;
75 using namespace com::sun::star::task;
76 using namespace com::sun::star::container;
77 using namespace com::sun::star::lang;
78 using namespace com::sun::star::uno;
79 using namespace com::sun::star::ucb;
80 using namespace com::sun::star::beans;
81 using namespace com::sun::star::io;
82 using namespace com::sun::star::sdbc;
83 
84 
85 // Content Implementation.
86 
88  FTPContentProvider* pProvider,
89  const Reference< XContentIdentifier >& Identifier,
90  const FTPURL& aFTPURL)
91  : ContentImplHelper(rxContext,pProvider,Identifier)
92  , m_pFCP(pProvider)
93  , m_aFTPURL(aFTPURL)
94  , m_bInserted(false)
95  , m_bTitleSet(false)
96 {
97 }
98 
100  FTPContentProvider* pProvider,
101  const Reference< XContentIdentifier >& Identifier,
102  const ContentInfo& Info)
103  : ContentImplHelper(rxContext,pProvider,Identifier)
104  , m_pFCP(pProvider)
105  , m_aFTPURL(Identifier->getContentIdentifier(), pProvider)
106  , m_bInserted(true)
107  , m_bTitleSet(false)
108  , m_aInfo(Info)
109 {
110 }
111 
113 {
114 }
115 
116 // XInterface methods.
117 
118 void SAL_CALL FTPContent::acquire()
119  throw()
120 {
121  OWeakObject::acquire();
122 }
123 
124 void SAL_CALL FTPContent::release()
125  throw()
126 {
127  OWeakObject::release();
128 }
129 
130 css::uno::Any SAL_CALL FTPContent::queryInterface( const css::uno::Type & rType )
131 {
132  css::uno::Any aRet = cppu::queryInterface( rType,
133  static_cast< XTypeProvider* >(this),
134  static_cast< XServiceInfo* >(this),
135  static_cast< XContent* >(this),
136  static_cast< XCommandProcessor* >(this),
137  static_cast< XContentCreator* >(this),
138  static_cast< XChild* >(this)
139  );
140  return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
141 }
142 
143 // XTypeProvider methods.
144 
145 css::uno::Sequence< sal_Int8 > SAL_CALL FTPContent::getImplementationId()
146 {
147  return css::uno::Sequence<sal_Int8>();
148 }
149 
150 css::uno::Sequence< css::uno::Type > SAL_CALL FTPContent::getTypes()
151 {
152  static cppu::OTypeCollection s_aCollection(
159  );
160 
161  return s_aCollection.getTypes();
162 }
163 
164 
165 // XServiceInfo methods.
166 
168 {
169  return "com.sun.star.comp.FTPContent";
170 }
171 
172 sal_Bool SAL_CALL FTPContent::supportsService( const OUString& ServiceName )
173 {
174  return cppu::supportsService( this, ServiceName );
175 }
176 
177 css::uno::Sequence< OUString > SAL_CALL FTPContent::getSupportedServiceNames()
178 {
179  return { "com.sun.star.ucb.FTPContent" };
180 }
181 
182 
183 // XContent methods.
184 
185 // virtual
186 OUString SAL_CALL FTPContent::getContentType()
187 {
188  return FTP_CONTENT_TYPE;
189 }
190 
191 // XCommandProcessor methods.
192 
193 //virtual
194 void SAL_CALL FTPContent::abort( sal_Int32 /*CommandId*/ )
195 {
196 }
197 
198 
200  const Reference<XContentProvider >& xProvider,
201  const Sequence<Property>& seq,
202  const std::vector<FTPDirentry>& dirvec)
203  : m_xContext(rxContext),
204  m_xProvider(xProvider),
205  m_seq(seq),
206  m_dirvec(dirvec)
207 {
208 }
209 
210 
212 {
213  return new ResultSetI(m_xContext,
214  m_xProvider,
215  m_seq,
216  m_dirvec);
217 }
218 
219 
220 // XCommandProcessor methods.
221 
222 namespace {
223 
224 enum ACTION { NOACTION,
225  THROWAUTHENTICATIONREQUEST,
226  THROWACCESSDENIED,
227  THROWINTERACTIVECONNECT,
228  THROWRESOLVENAME,
229  THROWQUOTE,
230  THROWNOFILE,
231  THROWGENERAL };
232 
233 }
234 
235 // virtual
236 Any SAL_CALL FTPContent::execute( const Command& aCommand,
237  sal_Int32 /*CommandId*/,
238  const Reference<
239  XCommandEnvironment >& Environment)
240 {
241  ACTION action(NOACTION);
242  Any aRet;
243 
244  while(true)
245  {
246  try
247  {
248  if(action == THROWAUTHENTICATIONREQUEST)
249  {
250  // try to get a continuation first
251  OUString aPassword,aAccount;
253  m_aFTPURL.port(),
255  aPassword,
256  aAccount);
259  m_aFTPURL.ident(false, false),
260  m_aFTPURL.host(), // ServerName
262  OUString(),
263  ucbhelper::SimpleAuthenticationRequest
264  ::ENTITY_FIXED,
266  ucbhelper::SimpleAuthenticationRequest
267  ::ENTITY_MODIFY,
268  aPassword));
269 
270  Reference<XInteractionHandler> xInteractionHandler;
271  if(Environment.is())
272  xInteractionHandler =
273  Environment->getInteractionHandler();
274 
275  if( xInteractionHandler.is()) {
276  xInteractionHandler->handle(p.get());
277 
278  Reference<XInterface> xSelection(
279  p->getSelection().get());
280 
282  xSelection,UNO_QUERY).is())
283  action = NOACTION;
285  xSelection,UNO_QUERY).is()) {
286  m_pFCP->setHost(
287  m_aFTPURL.host(),
288  m_aFTPURL.port(),
290  p->getAuthenticationSupplier()->getPassword(),
291  aAccount);
292  action = NOACTION;
293  }
294  }
295  aRet = p->getRequest();
296  }
297 
298 // if(aCommand.Name.equalsAscii(
299 // "getPropertyValues") &&
300 // action != NOACTION) {
301 // // It is not allowed to throw if
302 // // command is getPropertyValues
303 // rtl::Reference<ucbhelper::PropertyValueSet> xRow =
304 // new ucbhelper::PropertyValueSet(m_xSMgr);
305 // Sequence<Property> Properties;
306 // aCommand.Argument >>= Properties;
307 // for(int i = 0; i < Properties.getLength(); ++i)
308 // xRow->appendVoid(Properties[i]);
309 // aRet <<= Reference<XRow>(xRow.get());
310 // return aRet;
311 // }
312 
313  switch (action)
314  {
315  case NOACTION:
316  break;
317 
318  case THROWAUTHENTICATIONREQUEST:
320  aRet,
322  break;
323 
324  case THROWACCESSDENIED:
325  {
327  {
328  {"Uri", Any(m_aFTPURL.ident(false,false))}
329  }));
331  IOErrorCode_ACCESS_DENIED,
332  seq,
333  Environment);
334  break;
335  }
336  case THROWINTERACTIVECONNECT:
337  {
338  InteractiveNetworkConnectException excep;
339  excep.Server = m_aFTPURL.host();
340  aRet <<= excep;
342  aRet,
343  Environment);
344  break;
345  }
346  case THROWRESOLVENAME:
347  {
348  InteractiveNetworkResolveNameException excep;
349  excep.Server = m_aFTPURL.host();
350  aRet <<= excep;
352  aRet,
353  Environment);
354  break;
355  }
356  case THROWNOFILE:
357  {
359  {
360  {"Uri", Any(m_aFTPURL.ident(false,false))}
361  }));
363  IOErrorCode_NO_FILE,
364  seq,
365  Environment);
366  break;
367  }
368  case THROWQUOTE:
369  case THROWGENERAL:
371  IOErrorCode_GENERAL,
372  Sequence<Any>(0),
373  Environment);
374  break;
375  }
376 
377  if(aCommand.Name == "getPropertyValues") {
379  if(!(aCommand.Argument >>= Properties))
380  {
381  aRet <<= IllegalArgumentException(
382  "Wrong argument type!",
383  static_cast< cppu::OWeakObject * >(this),
384  -1);
386  }
387 
388  aRet <<= getPropertyValues(Properties);
389  }
390  else if(aCommand.Name == "setPropertyValues")
391  {
392  Sequence<PropertyValue> propertyValues;
393 
394  if( ! ( aCommand.Argument >>= propertyValues ) ) {
395  aRet <<= IllegalArgumentException(
396  "Wrong argument type!",
397  static_cast< cppu::OWeakObject * >(this),
398  -1);
400  }
401 
402  aRet <<= setPropertyValues(propertyValues);
403  }
404  else if(aCommand.Name == "getCommandInfo") {
405  // Note: Implemented by base class.
406  aRet <<= getCommandInfo(Environment);
407  }
408  else if(aCommand.Name == "getPropertySetInfo") {
409  // Note: Implemented by base class.
411  }
412  else if(aCommand.Name == "insert")
413  {
414  InsertCommandArgument aInsertArgument;
415  if ( ! ( aCommand.Argument >>= aInsertArgument ) ) {
416  aRet <<= IllegalArgumentException(
417  "Wrong argument type!",
418  static_cast< cppu::OWeakObject * >(this),
419  -1);
421  }
422  insert(aInsertArgument,Environment);
423  }
424  else if(aCommand.Name == "delete") {
425  m_aFTPURL.del();
426  deleted();
427  }
428  else if(aCommand.Name == "open") {
429  OpenCommandArgument2 aOpenCommand;
430  if ( !( aCommand.Argument >>= aOpenCommand ) ) {
431  aRet <<= IllegalArgumentException(
432  "Wrong argument type!",
433  static_cast< cppu::OWeakObject * >(this),
434  -1);
435 
437  }
438 
439  if(aOpenCommand.Mode == OpenMode::DOCUMENT) {
440  // Open as a document
442  xActiveDataSink(aOpenCommand.Sink,UNO_QUERY);
444  xOutputStream(aOpenCommand.Sink,UNO_QUERY);
445 
446  if(xActiveDataSink.is()) {
447  xActiveDataSink->setInputStream(
449  }
450  else if(xOutputStream.is()) {
453  for (;;) {
454  Sequence<sal_Int8> byte_seq(4096);
455  sal_Int32 n = xStream->readBytes(byte_seq, 4096);
456  if (n == 0) {
457  break;
458  }
459  try {
460  if(byte_seq.getLength() != n)
461  byte_seq.realloc(n);
462  xOutputStream->writeBytes(byte_seq);
463  } catch(const NotConnectedException&) {
464 
465  } catch(const BufferSizeExceededException&) {
466 
467  } catch(const IOException&) {
468 
469  }
470  }
471  }
472  else {
473  aRet <<= UnsupportedDataSinkException(
474  OUString(),
475  static_cast< cppu::OWeakObject * >(this),
476  aOpenCommand.Sink);
478  }
479  }
480  else if(aOpenCommand.Mode == OpenMode::ALL ||
481  aOpenCommand.Mode == OpenMode::DOCUMENTS ||
482  aOpenCommand.Mode == OpenMode::FOLDERS ) {
483  std::vector<FTPDirentry> resvec =
484  m_aFTPURL.list(sal_Int16(aOpenCommand.Mode));
486  = new DynamicResultSet(
487  m_xContext,
488  aOpenCommand,
489  std::make_unique<ResultSetFactory>(m_xContext,
490  m_xProvider.get(),
491  aOpenCommand.Properties,
492  resvec));
493  aRet <<= xSet;
494  }
495  else if(aOpenCommand.Mode ==
496  OpenMode::DOCUMENT_SHARE_DENY_NONE ||
497  aOpenCommand.Mode ==
498  OpenMode::DOCUMENT_SHARE_DENY_WRITE) {
499  // Unsupported OpenMode
500  aRet <<= UnsupportedOpenModeException(
501  OUString(),
502  static_cast< cppu::OWeakObject * >(this),
503  static_cast< sal_Int16 >(aOpenCommand.Mode));
505  }
506  else {
507  aRet <<= IllegalArgumentException(
508  "Unexpected OpenMode!",
509  static_cast< cppu::OWeakObject * >(this),
510  -1);
511 
513  }
514  } else if(aCommand.Name == "createNewContent") {
515  ContentInfo aArg;
516  if (!(aCommand.Argument >>= aArg)) {
518  makeAny(
519  IllegalArgumentException(
520  "Wrong argument type!",
521  static_cast< cppu::OWeakObject * >(this),
522  -1)),
523  Environment);
524  // Unreachable
525  }
526  aRet <<= createNewContent(aArg);
527  } else {
528  aRet <<= UnsupportedCommandException(
529  aCommand.Name,
530  static_cast< cppu::OWeakObject * >(this));
532  }
533 
534  return aRet;
535  }
536  catch(const curl_exception& e)
537  {
538  if(e.code() == CURLE_COULDNT_CONNECT)
539  action = THROWINTERACTIVECONNECT;
540  else if(e.code() == CURLE_COULDNT_RESOLVE_HOST )
541  action = THROWRESOLVENAME;
542  else if(e.code() == CURLE_FTP_USER_PASSWORD_INCORRECT ||
543  e.code() == CURLE_LOGIN_DENIED ||
544  e.code() == CURLE_BAD_PASSWORD_ENTERED ||
545  e.code() == CURLE_FTP_WEIRD_PASS_REPLY)
546  action = THROWAUTHENTICATIONREQUEST;
547  else if(e.code() == CURLE_FTP_ACCESS_DENIED)
548  action = THROWACCESSDENIED;
549  else if(e.code() == CURLE_FTP_QUOTE_ERROR)
550  action = THROWQUOTE;
551  else if(e.code() == CURLE_FTP_COULDNT_RETR_FILE)
552  action = THROWNOFILE;
553  else
554  // nothing known about the cause of the error
555  action = THROWGENERAL;
556  }
557  }
558 }
559 
560 #define FTP_FILE "application/vnd.sun.staroffice.ftp-file"
561 
562 #define FTP_FOLDER "application/vnd.sun.staroffice.ftp-folder"
563 
564 Sequence<ContentInfo > SAL_CALL
566 {
568 }
569 
570 // static
573 {
575 
576  seq[0].Type = FTP_FILE;
577  seq[0].Attributes = ContentInfoAttribute::INSERT_WITH_INPUTSTREAM
578  | ContentInfoAttribute::KIND_DOCUMENT;
579  Sequence< Property > props( 1 );
580  props[0] = Property(
581  "Title",
582  -1,
584  PropertyAttribute::MAYBEVOID
585  | PropertyAttribute::BOUND );
586  seq[0].Properties = props;
587 
588  // folder
589  seq[1].Type = FTP_FOLDER;
590  seq[1].Attributes = ContentInfoAttribute::KIND_FOLDER;
591  seq[1].Properties = props;
592 
593  return seq;
594 }
595 
596 Reference<XContent > SAL_CALL
598 {
599  if( Info.Type =="application/vnd.sun.staroffice.ftp-file" || Info.Type == "application/vnd.sun.staroffice.ftp-folder" )
600  return new FTPContent(m_xContext,
601  m_pFCP,
602  m_xIdentifier,Info);
603  else
604  return Reference<XContent>(nullptr);
605 }
606 
607 
608 Reference<XInterface > SAL_CALL
610 {
612  xIdent(new FTPContentIdentifier(m_aFTPURL.parent()));
613  return Reference<XInterface>( m_xProvider->queryContent(xIdent), UNO_QUERY );
614 }
615 
616 
617 void SAL_CALL
619 {
620  throw NoSupportException();
621 }
622 
623 
625 {
626  return m_aFTPURL.parent();
627 }
628 
629 namespace {
630 
631 class InsertData
632  : public CurlInput {
633 
634 public:
635 
636  explicit InsertData(const Reference<XInputStream>& xInputStream)
637  : m_xInputStream(xInputStream) { }
638  virtual ~InsertData() {}
639 
640  // returns the number of bytes actually read
641  virtual sal_Int32 read(sal_Int8 *dest,sal_Int32 nBytesRequested) override;
642 
643 private:
644 
645  Reference<XInputStream> m_xInputStream;
646 };
647 
648 }
649 
650 sal_Int32 InsertData::read(sal_Int8 *dest,sal_Int32 nBytesRequested)
651 {
652  sal_Int32 m = 0;
653 
654  if(m_xInputStream.is()) {
655  Sequence<sal_Int8> seq(nBytesRequested);
656  m = m_xInputStream->readBytes(seq,nBytesRequested);
657  memcpy(dest,seq.getConstArray(),m);
658  }
659  return m;
660 }
661 
662 
663 void FTPContent::insert(const InsertCommandArgument& aInsertCommand,
665 {
666  osl::MutexGuard aGuard(m_aMutex);
667 
668  if(m_bInserted && !m_bTitleSet) {
669  MissingPropertiesException excep;
670  excep.Properties.realloc(1);
671  excep.Properties[0] = "Title";
673  }
674 
675  if(m_bInserted &&
676  m_aInfo.Type == FTP_FILE &&
677  !aInsertCommand.Data.is())
678  {
679  MissingInputStreamException excep;
681  }
682 
683  bool bReplace(aInsertCommand.ReplaceExisting);
684 
685  retry:
686  try {
687  if(m_aInfo.Type == FTP_FILE) {
688  InsertData data(aInsertCommand.Data);
689  m_aFTPURL.insert(bReplace,&data);
690  } else if(m_aInfo.Type == FTP_FOLDER)
691  m_aFTPURL.mkdir(bReplace);
692  } catch(const curl_exception& e) {
695  // Interact
697  if(Env.is())
698  xInt = Env->getInteractionHandler();
699 
700  UnsupportedNameClashException excep;
701  excep.NameClash = 0; //NameClash::ERROR;
702 
703  if(!xInt.is()) {
705  }
706 
707  XInteractionRequestImpl request;
708  const Reference<XInteractionRequest>& xReq(request.getRequest());
709  xInt->handle(xReq);
710  if (request.approved()) {
711  bReplace = true;
712  goto retry;
713  }
714  else
715  throw excep;
716  }
717  else
718  throw;
719  }
720 
721  // May not be reached, because both mkdir and insert can throw curl-
722  // exceptions
723  m_bInserted = false;
724  inserted();
725 }
726 
727 
729  const Sequence< Property >& seqProp
730 )
731 {
734 
735  FTPDirentry aDirEntry = m_aFTPURL.direntry();
736 
737  for(const auto& rProp : seqProp) {
738  const OUString& Name = rProp.Name;
739  if(Name == "Title")
740  xRow->appendString(rProp,aDirEntry.m_aName);
741  else if(Name == "CreatableContentsInfo")
742  xRow->appendObject(rProp,
744  else if(aDirEntry.m_nMode != INETCOREFTP_FILEMODE_UNKNOWN) {
745  if(Name == "ContentType")
746  xRow->appendString(rProp,
747  (aDirEntry.m_nMode & INETCOREFTP_FILEMODE_ISDIR)
748  ? OUString(FTP_FOLDER)
749  : OUString(FTP_FILE) );
750  else if(Name == "IsReadOnly")
751  xRow->appendBoolean(rProp,
752  (aDirEntry.m_nMode
753  & INETCOREFTP_FILEMODE_WRITE) == 0 );
754  else if(Name == "IsDocument")
755  xRow->appendBoolean(rProp,
756  (aDirEntry.m_nMode &
758  else if(Name == "IsFolder")
759  xRow->appendBoolean(rProp,
760  (aDirEntry.m_nMode &
762  else if(Name == "Size")
763  xRow->appendLong(rProp,
764  aDirEntry.m_nSize);
765  else if(Name == "DateCreated")
766  xRow->appendTimestamp(rProp,
767  aDirEntry.m_aDate);
768  else
769  xRow->appendVoid(rProp);
770  } else
771  xRow->appendVoid(rProp);
772  }
773 
774  return Reference<XRow>(xRow.get());
775 }
776 
777 
779  const Sequence<PropertyValue>& seqPropVal)
780 {
781  Sequence<Any> ret(seqPropVal.getLength());
783 
784  osl::MutexGuard aGuard(m_aMutex);
785  for(sal_Int32 i = 0; i < ret.getLength(); ++i) {
786  if ( seqPropVal[i].Name == "Title" ) {
787  OUString Title;
788  if(!(seqPropVal[i].Value >>= Title)) {
789  ret[i] <<= IllegalTypeException();
790  continue;
791  } else if(Title.isEmpty()) {
792  ret[i] <<= IllegalArgumentException();
793  continue;
794  }
795 
796  if(m_bInserted) {
797  m_aFTPURL.child(Title);
798  m_xIdentifier =
799  new FTPContentIdentifier(m_aFTPURL.ident(false,false));
800  m_bTitleSet = true;
801  } else
802  try {
803  OUString OldTitle = m_aFTPURL.ren(Title);
804  evt.realloc(1);
805  evt[0].PropertyName = "Title";
806  evt[0].Further = false;
807  evt[0].PropertyHandle = -1;
808  evt[0].OldValue <<= OldTitle;
809  evt[0].NewValue <<= Title;
810  } catch(const curl_exception&) {
811  InteractiveIOException excep;
812  // any better possibility here?
813  // ( the error code is always CURLE_FTP_QUOTE_ERROR )
814  excep.Code = IOErrorCode_ACCESS_DENIED;
815  ret[i] <<= excep;
816  }
817  } else {
818  Sequence<Property> props =
820 
821  // either unknown or read-only
822  ret[i] <<= UnknownPropertyException();
823  const auto& rName = seqPropVal[i].Name;
824  auto pProp = std::find_if(props.begin(), props.end(),
825  [&rName](const Property& rProp) { return rProp.Name == rName; });
826  if (pProp != props.end()) {
827  ret[i] <<= IllegalAccessException(
828  "Property is read-only!",
829  //props[j].Attributes & PropertyAttribute::READONLY
830  // ? "Property is read-only!"
831  // : "Access denied!"),
832  static_cast< cppu::OWeakObject * >( this ));
833  }
834  }
835  }
836 
837  if(evt.hasElements()) {
838  // title has changed
840  (void)exchange(new FTPContentIdentifier(m_aFTPURL.ident(false,false)));
841  }
842 
843  return ret;
844 }
845 
846 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
css::uno::Reference< css::uno::XComponentContext > m_xContext
const OUString & host() const
Definition: ftpurl.hxx:88
virtual css::uno::Any SAL_CALL queryInterface(const css::uno::Type &rType) override
Definition: ftpcontent.cxx:130
signed char sal_Int8
css::ucb::ContentInfo const m_aInfo
Definition: ftpcontent.hxx:116
virtual OUString SAL_CALL getImplementationName() override
Definition: ftpcontent.cxx:167
virtual OUString getParentURL() override
Definition: ftpcontent.cxx:624
bool setHost(const OUString &host, const OUString &port, const OUString &username, const OUString &password, const OUString &account)
sal_Int64 n
css::uno::Reference< css::ucb::XContentProvider > m_xProvider
ACTION
Definition: ftpcontent.cxx:224
sal_Int32 code() const
Definition: ftpurl.hxx:57
OUString Name
std::vector< FTPDirentry > const m_dirvec
Title
const OUString & username() const
Definition: ftpurl.hxx:92
virtual css::uno::Reference< css::ucb::XContent > SAL_CALL createNewContent(const css::ucb::ContentInfo &Info) override
Definition: ftpcontent.cxx:597
virtual css::uno::Sequence< css::beans::Property > getProperties(const css::uno::Reference< css::ucb::XCommandEnvironment > &xEnv) override
css::uno::Reference< css::task::XInteractionRequest > const & getRequest() const
Definition: ftpintreq.hxx:67
css::uno::Sequence< css::uno::Any > setPropertyValues(const css::uno::Sequence< css::beans::PropertyValue > &seqPropVal)
Definition: ftpcontent.cxx:778
virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getParent() override
Definition: ftpcontent.cxx:609
Value
void mkdir(bool ReplaceExisting) const
Definition: ftpurl.cxx:666
Reference< XRow > xRow
virtual void SAL_CALL abort(sal_Int32 CommandId) override
Definition: ftpcontent.cxx:194
virtual void SAL_CALL setParent(const css::uno::Reference< css::uno::XInterface > &Parent) override
Definition: ftpcontent.cxx:618
Reference< XInputStream > xStream
OUString parent(bool internal=false) const
returns the parent url.
Definition: ftpurl.cxx:286
bool CPPUHELPER_DLLPUBLIC supportsService(css::lang::XServiceInfo *implementation, rtl::OUString const &name)
std::vector< FTPDirentry > list(sal_Int16 nMode) const
Definition: ftpurl.cxx:425
sal_uInt32 m_nMode
Definition: ftpdirp.hxx:76
void notifyPropertiesChange(const css::uno::Sequence< css::beans::PropertyChangeEvent > &evt) const
#define FTP_FILE
Definition: ftpcontent.cxx:560
FTPDirentry direntry() const
Definition: ftpurl.cxx:590
css::uno::Reference< css::uno::XComponentContext > m_xContext
ResultSetFactory(const css::uno::Reference< css::uno::XComponentContext > &rxContext, const css::uno::Reference< css::ucb::XContentProvider > &xProvider, const css::uno::Sequence< css::beans::Property > &seq, const std::vector< FTPDirentry > &dirvec)
Definition: ftpcontent.cxx:199
#define FTP_FOLDER
Definition: ftpcontent.cxx:562
OUString ren(const OUString &NewTitle)
Definition: ftpurl.cxx:715
void cancelCommandExecution(const uno::Any &rException, const uno::Reference< ucb::XCommandEnvironment > &xEnv)
void del() const
Definition: ftpurl.cxx:755
#define FTP_CONTENT_TYPE
css::uno::Sequence< css::uno::Any > InitAnyPropertySequence(::std::initializer_list< ::std::pair< OUString, css::uno::Any > > vInit)
css::uno::Reference< css::ucb::XContentIdentifier > m_xIdentifier
void insert(bool ReplaceExisting, void *stream) const
Definition: ftpurl.cxx:635
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: ftpcontent.cxx:177
void insert(const css::ucb::InsertCommandArgument &, const css::uno::Reference< css::ucb::XCommandEnvironment > &)
Definition: ftpcontent.cxx:663
int i
virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() override
Definition: ftpcontent.cxx:145
void child(const OUString &title)
sets the unencoded title
Definition: ftpurl.cxx:338
css::uno::Reference< css::beans::XPropertySetInfo > getPropertySetInfo(const css::uno::Reference< css::ucb::XCommandEnvironment > &xEnv, bool bCache=true)
unsigned char sal_Bool
css::uno::Reference< css::ucb::XCommandInfo > getCommandInfo(const css::uno::Reference< css::ucb::XCommandEnvironment > &xEnv, bool bCache=true)
Definition of ftpcontentprovider.
static css::uno::Sequence< css::ucb::ContentInfo > queryCreatableContentsInfo_Static()
Definition: ftpcontent.cxx:572
FTPContent(const css::uno::Reference< css::uno::XComponentContext > &rxContext, FTPContentProvider *pProvider, const css::uno::Reference< css::ucb::XContentIdentifier > &Identifier, const FTPURL &FtpUrl)
virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() override
Definition: ftpcontent.cxx:150
css::uno::Sequence< css::beans::Property > const m_seq
const OUString & port() const
Definition: ftpurl.hxx:90
virtual ~FTPContent() override
Definition: ftpcontent.cxx:112
rtl::Reference< ContentProviderImplHelper > m_xProvider
virtual void SAL_CALL acquire() override
Definition: ftpcontent.cxx:118
virtual css::uno::Sequence< css::ucb::ContentInfo > SAL_CALL queryCreatableContentsInfo() override
Definition: ftpcontent.cxx:565
virtual void SAL_CALL release() override
Definition: ftpcontent.cxx:124
virtual css::uno::Any SAL_CALL execute(const css::ucb::Command &aCommand, sal_Int32 CommandId, const css::uno::Reference< css::ucb::XCommandEnvironment > &Environment) override
Definition: ftpcontent.cxx:236
virtual OUString SAL_CALL getContentType() override
Definition: ftpcontent.cxx:186
DateTime m_aDate
Definition: ftpdirp.hxx:75
void * p
css::uno::Reference< css::sdbc::XRow > getPropertyValues(const css::uno::Sequence< css::beans::Property > &seqProp)
Definition: ftpcontent.cxx:728
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: ftpcontent.cxx:172
void forHost(const OUString &host, const OUString &port, const OUString &username, OUString &password, OUString &account)
host is in the form host:port.
css::uno::Sequence< css::uno::Type > SAL_CALL getTypes()
sal_uInt32 m_nSize
Definition: ftpdirp.hxx:77
oslFileHandle open()
Definition: ftpurl.cxx:388
ResultSetBase * createResultSet()
Definition: ftpcontent.cxx:211
Reference< XComponentContext > m_xContext
bool exchange(const css::uno::Reference< css::ucb::XContentIdentifier > &rNewId)
FTPContentProvider * m_pFCP
Definition: ftpcontent.hxx:112
css::uno::Any SAL_CALL queryInterface(const css::uno::Type &rType, Interface1 *p1)
OUString ident(bool withslash, bool internal) const
This returns the URL, but cleaned from unnessary ellipses.
Definition: ftpurl.cxx:237
OUString m_aName
Definition: ftpdirp.hxx:74
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
css::uno::Any SAL_CALL makeAny(const SharedUNOComponent< INTERFACE, COMPONENT > &value)