ucb/source/ucp/webdav/DAVResourceAccess.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: DAVResourceAccess.cxx,v $
  10  * $Revision: 1.29.16.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_ucb.hxx"
  33
  34 #include "osl/diagnose.h"
  35
  36 #include "com/sun/star/task/XInteractionAbort.hpp"
  37 #include "com/sun/star/ucb/XWebDAVCommandEnvironment.hpp"
  38
  39 #include "ucbhelper/simpleauthenticationrequest.hxx"
  40 #include "comphelper/seekableinput.hxx"
  41
  42 #include "DAVAuthListenerImpl.hxx"
  43 #include "DAVResourceAccess.hxx"
  44
  45 #include <comphelper/processfactory.hxx>
  46 #include <ucbhelper/commandenvironment.hxx>
  47
  48 using namespace webdav_ucp;
  49 using namespace com::sun::star;
  50
  51 //=========================================================================
  52 //=========================================================================
  53 //
  54 // DAVAuthListener_Impl Implementation.
  55 //
  56 //=========================================================================
  57 //=========================================================================
  58
  59 //=========================================================================
  60 // virtual
  61 int DAVAuthListener_Impl::authenticate(
  62     const ::rtl::OUString & inRealm,
  63     const ::rtl::OUString & inHostName,
  64     ::rtl::OUString & inoutUserName,
  65     ::rtl::OUString & outPassWord,
  66     sal_Bool bAllowPersistentStoring,
  67     sal_Bool bCanUseSystemCredentials )
  68 {
  69     uno::Reference< task::XInteractionHandler > xIH;
  70
  71     if ( m_xEnv.is() )
  72     {
  73         xIH = m_xEnv->getInteractionHandler();
  74     }
  75     else
  76     {
  77         xIH = DAVResourceAccess::createCommandEnvironment()->getInteractionHandler();
  78     }
  79
  80     {
  81         {
  82             // #102871# - Supply username and password from previous try.
  83             // Password container service depends on this!
  84             if ( inoutUserName.getLength() == 0 )
  85                 inoutUserName = m_aPrevUsername;
  86
  87             if ( outPassWord.getLength() == 0 )
  88                 outPassWord = m_aPrevPassword;
  89
  90             rtl::Reference< ucbhelper::SimpleAuthenticationRequest > xRequest
  91                 = new ucbhelper::SimpleAuthenticationRequest( m_aURL,
  92                                                               inHostName,
  93                                                               inRealm,
  94                                                               inoutUserName,
  95                                                               outPassWord,
  96                                                               ::rtl::OUString(),
  97                                                               bAllowPersistentStoring,
  98                                                               bCanUseSystemCredentials );
  99             xIH->handle( xRequest.get() );
 100
 101             rtl::Reference< ucbhelper::InteractionContinuation > xSelection
 102                 = xRequest->getSelection();
 103
 104             if ( xSelection.is() )
 105             {
 106                 // Handler handled the request.
 107                 uno::Reference< task::XInteractionAbort > xAbort(
 108                     xSelection.get(), uno::UNO_QUERY );
 109                 if ( !xAbort.is() )
 110                 {
 111                     const rtl::Reference<
 112                         ucbhelper::InteractionSupplyAuthentication > & xSupp
 113                         = xRequest->getAuthenticationSupplier();
 114
 115                     sal_Bool bUseSystemCredentials = sal_False;
 116
 117                     if ( bCanUseSystemCredentials )
 118                         bUseSystemCredentials = xSupp->getUseSystemCredentials();
 119
 120                     if ( bUseSystemCredentials )
 121                     {
 122                         // This is the (strange) way to tell neon to use
 123                         // system credentials.
 124                         inoutUserName = rtl::OUString();
 125                         outPassWord   = rtl::OUString();
 126                     }
 127                     else
 128                     {
 129                         inoutUserName = xSupp->getUserName();
 130                         outPassWord   = xSupp->getPassword();
 131                     }
 132
 133                     // #102871# - Remember username and password.
 134                     m_aPrevUsername = inoutUserName;
 135                     m_aPrevPassword = outPassWord;
 136
 137                     // go on.
 138                     return 0;
 139                 }
 140             }
 141         }
 142     }
 143     // Abort.
 144     return -1;
 145 }
 146
 147 //=========================================================================
 148 //=========================================================================
 149 //
 150 // DAVResourceAccess Implementation.
 151 //
 152 //=========================================================================
 153 //=========================================================================
 154
 155 //=========================================================================
 156 DAVResourceAccess::DAVResourceAccess(
 157     const uno::Reference< lang::XMultiServiceFactory > & rSMgr,
 158     rtl::Reference< DAVSessionFactory > const & rSessionFactory,
 159     const rtl::OUString & rURL )
 160 : m_aURL( rURL ),
 161   m_xSessionFactory( rSessionFactory ),
 162   m_xSMgr( rSMgr )
 163 {
 164 }
 165
 166 //=========================================================================
 167 DAVResourceAccess::DAVResourceAccess( const DAVResourceAccess & rOther )
 168 : m_aURL( rOther.m_aURL ),
 169   m_aPath( rOther.m_aPath ),
 170   m_xSession( rOther.m_xSession ),
 171   m_xSessionFactory( rOther.m_xSessionFactory ),
 172   m_xSMgr( rOther.m_xSMgr ),
 173   m_aRedirectURIs( rOther.m_aRedirectURIs )
 174 {
 175 }
 176
 177 //=========================================================================
 178 DAVResourceAccess & DAVResourceAccess::operator=(
 179     const DAVResourceAccess & rOther )
 180 {
 181     m_aURL            = rOther.m_aURL;
 182     m_aPath           = rOther.m_aPath;
 183     m_xSession        = rOther.m_xSession;
 184     m_xSessionFactory = rOther.m_xSessionFactory;
 185     m_xSMgr           = rOther.m_xSMgr;
 186     m_aRedirectURIs   = rOther.m_aRedirectURIs;
 187
 188     return *this;
 189 }
 190
 191 //=========================================================================
 192 void DAVResourceAccess::OPTIONS(
 193     DAVCapabilities & rCapabilities,
 194     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 195   throw( DAVException )
 196 {
 197     initialize();
 198
 199     bool bRetry;
 200     int errorCount = 0;
 201     do
 202     {
 203         bRetry = false;
 204         try
 205         {
 206             DAVRequestHeaders aHeaders;
 207             getUserRequestHeaders( xEnv,
 208                                    getRequestURI(),
 209                                    rtl::OUString::createFromAscii(
 210                                        "OPTIONS" ),
 211                                    aHeaders );
 212
 213             m_xSession->OPTIONS( getRequestURI(),
 214                                  rCapabilities,
 215                                  DAVRequestEnvironment(
 216                                      getRequestURI(),
 217                                      new DAVAuthListener_Impl( xEnv, m_aURL ),
 218                                      aHeaders, xEnv) );
 219         }
 220         catch ( DAVException & e )
 221         {
 222             errorCount++;
 223             bRetry = handleException( e, errorCount );
 224             if ( !bRetry )
 225                 throw;
 226         }
 227     }
 228     while ( bRetry );
 229 }
 230
 231 //=========================================================================
 232 void DAVResourceAccess::PROPFIND(
 233     const Depth nDepth,
 234     const std::vector< rtl::OUString > & rPropertyNames,
 235     std::vector< DAVResource > & rResources,
 236     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 237   throw( DAVException )
 238 {
 239     initialize();
 240
 241     int errorCount = 0;
 242     bool bRetry;
 243     do
 244     {
 245         bRetry = false;
 246         try
 247         {
 248             DAVRequestHeaders aHeaders;
 249
 250             getUserRequestHeaders( xEnv,
 251                                    getRequestURI(),
 252                                    rtl::OUString::createFromAscii(
 253                                        "PROPFIND" ),
 254                                    aHeaders );
 255
 256             m_xSession->PROPFIND( getRequestURI(),
 257                                   nDepth,
 258                                   rPropertyNames,
 259                                   rResources,
 260                                   DAVRequestEnvironment(
 261                                       getRequestURI(),
 262                                       new DAVAuthListener_Impl( xEnv, m_aURL ),
 263                                       aHeaders, xEnv ) );
 264         }
 265         catch ( DAVException & e )
 266         {
 267             errorCount++;
 268             bRetry = handleException( e, errorCount );
 269             if ( !bRetry )
 270                 throw;
 271         }
 272     }
 273     while ( bRetry );
 274 }
 275
 276 //=========================================================================
 277 void DAVResourceAccess::PROPFIND(
 278     const Depth nDepth,
 279     std::vector< DAVResourceInfo > & rResInfo,
 280     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 281   throw( DAVException )
 282 {
 283     initialize();
 284
 285     int errorCount = 0;
 286     bool bRetry;
 287     do
 288     {
 289         bRetry = false;
 290         try
 291         {
 292             DAVRequestHeaders aHeaders;
 293             getUserRequestHeaders( xEnv,
 294                                    getRequestURI(),
 295                                    rtl::OUString::createFromAscii(
 296                                        "PROPFIND" ),
 297                                    aHeaders );
 298
 299             m_xSession->PROPFIND( getRequestURI(),
 300                                   nDepth,
 301                                   rResInfo,
 302                                   DAVRequestEnvironment(
 303                                       getRequestURI(),
 304                                       new DAVAuthListener_Impl( xEnv, m_aURL ),
 305                                       aHeaders, xEnv ) ) ;
 306         }
 307         catch ( DAVException & e )
 308         {
 309             errorCount++;
 310             bRetry = handleException( e, errorCount );
 311             if ( !bRetry )
 312                 throw;
 313         }
 314     }
 315     while ( bRetry );
 316 }
 317
 318 //=========================================================================
 319 void DAVResourceAccess::PROPPATCH(
 320     const std::vector< ProppatchValue >& rValues,
 321     const uno::Reference< ucb::XCommandEnvironment >& xEnv )
 322   throw( DAVException )
 323 {
 324     initialize();
 325
 326     int errorCount = 0;
 327     bool bRetry;
 328     do
 329     {
 330         bRetry = false;
 331         try
 332         {
 333             DAVRequestHeaders aHeaders;
 334             getUserRequestHeaders( xEnv,
 335                                    getRequestURI(),
 336                                    rtl::OUString::createFromAscii(
 337                                        "PROPPATCH" ),
 338                                    aHeaders );
 339
 340             m_xSession->PROPPATCH( getRequestURI(),
 341                                    rValues,
 342                                    DAVRequestEnvironment(
 343                                        getRequestURI(),
 344                                        new DAVAuthListener_Impl( xEnv, m_aURL ),
 345                                        aHeaders, xEnv ) );
 346         }
 347         catch ( DAVException & e )
 348         {
 349             errorCount++;
 350             bRetry = handleException( e, errorCount );
 351             if ( !bRetry )
 352                 throw;
 353         }
 354     }
 355     while ( bRetry );
 356 }
 357
 358 //=========================================================================
 359 void DAVResourceAccess::HEAD(
 360     const std::vector< rtl::OUString > & rHeaderNames,
 361     DAVResource & rResource,
 362     const uno::Reference< ucb::XCommandEnvironment >& xEnv )
 363   throw( DAVException )
 364 {
 365     initialize();
 366     int errorCount = 0;
 367     bool bRetry;
 368     do
 369     {
 370         bRetry = false;
 371         try
 372         {
 373             DAVRequestHeaders aHeaders;
 374             getUserRequestHeaders( xEnv,
 375                                    getRequestURI(),
 376                                    rtl::OUString::createFromAscii( "HEAD" ),
 377                                    aHeaders );
 378
 379             m_xSession->HEAD( getRequestURI(),
 380                               rHeaderNames,
 381                               rResource,
 382                               DAVRequestEnvironment(
 383                                   getRequestURI(),
 384                                   new DAVAuthListener_Impl( xEnv, m_aURL ),
 385                                   aHeaders, xEnv ) );
 386         }
 387         catch ( DAVException & e )
 388         {
 389             errorCount++;
 390             bRetry = handleException( e, errorCount );
 391             if ( !bRetry )
 392                 throw;
 393         }
 394     }
 395     while ( bRetry );
 396 }
 397
 398 //=========================================================================
 399 uno::Reference< io::XInputStream > DAVResourceAccess::GET(
 400     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 401   throw( DAVException )
 402 {
 403     initialize();
 404
 405     uno::Reference< io::XInputStream > xStream;
 406     int errorCount = 0;
 407     bool bRetry;
 408     do
 409     {
 410         bRetry = false;
 411         try
 412         {
 413             DAVRequestHeaders aHeaders;
 414             getUserRequestHeaders( xEnv,
 415                                    getRequestURI(),
 416                                    rtl::OUString::createFromAscii( "GET" ),
 417                                    aHeaders );
 418
 419             xStream = m_xSession->GET( getRequestURI(),
 420                                        DAVRequestEnvironment(
 421                                            getRequestURI(),
 422                                            new DAVAuthListener_Impl( xEnv, m_aURL ),
 423                                            aHeaders, xEnv ) );
 424         }
 425         catch ( DAVException & e )
 426         {
 427             errorCount++;
 428             bRetry = handleException( e, errorCount );
 429             if ( !bRetry )
 430                 throw;
 431         }
 432     }
 433     while ( bRetry );
 434
 435     return xStream;
 436 }
 437
 438 //=========================================================================
 439 void DAVResourceAccess::GET(
 440     uno::Reference< io::XOutputStream > & rStream,
 441     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 442   throw( DAVException )
 443 {
 444     initialize();
 445
 446     int errorCount = 0;
 447     bool bRetry;
 448     do
 449     {
 450         bRetry = false;
 451         try
 452         {
 453             DAVRequestHeaders aHeaders;
 454             getUserRequestHeaders( xEnv,
 455                                    getRequestURI(),
 456                                    rtl::OUString::createFromAscii( "GET" ),
 457                                    aHeaders );
 458
 459             m_xSession->GET( getRequestURI(),
 460                              rStream,
 461                              DAVRequestEnvironment(
 462                                  getRequestURI(),
 463                                  new DAVAuthListener_Impl( xEnv, m_aURL ),
 464                                  aHeaders, xEnv ) );
 465         }
 466         catch ( DAVException & e )
 467         {
 468             errorCount++;
 469             bRetry = handleException( e, errorCount );
 470             if ( !bRetry )
 471                 throw;
 472         }
 473     }
 474     while ( bRetry );
 475 }
 476
 477 //=========================================================================
 478 uno::Reference< io::XStream > DAVResourceAccess::GET(
 479     const std::vector< rtl::OUString > & rHeaderNames,
 480     DAVResource & rResource,
 481     const uno::Reference< ucb::XCommandEnvironment > & xEnv,
 482     sal_Bool bAllowEmpty )
 483   throw( DAVException )
 484 {
 485     initialize();
 486
 487     uno::Reference< io::XStream > xStream;
 488     int errorCount = 0;
 489     bool bRetry;
 490     do
 491     {
 492         bRetry = false;
 493         try
 494         {
 495             DAVRequestHeaders aHeaders;
 496             getUserRequestHeaders( xEnv,
 497                                    getRequestURI(),
 498                                    rtl::OUString::createFromAscii( "GET" ),
 499                                    aHeaders );
 500
 501             xStream = m_xSession->GET( getRequestURI(),
 502                                        rHeaderNames,
 503                                        rResource,
 504                                        DAVRequestEnvironment(
 505                                            getRequestURI(),
 506                                            new DAVAuthListener_Impl( xEnv, m_aURL ),
 507                                            aHeaders, xEnv ),
 508                                        bAllowEmpty );
 509         }
 510         catch ( DAVException & e )
 511         {
 512             errorCount++;
 513             bRetry = handleException( e, errorCount );
 514             if ( !bRetry )
 515                 throw;
 516         }
 517     }
 518     while ( bRetry );
 519
 520     return xStream;
 521 }
 522
 523 //=========================================================================
 524 void DAVResourceAccess::GET(
 525     uno::Reference< io::XOutputStream > & rStream,
 526     const std::vector< rtl::OUString > & rHeaderNames,
 527     DAVResource & rResource,
 528     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 529   throw( DAVException )
 530 {
 531     initialize();
 532
 533     bool bRetry;
 534     int errorCount = 0;
 535     do
 536     {
 537         bRetry = false;
 538         try
 539         {
 540             DAVRequestHeaders aHeaders;
 541             getUserRequestHeaders( xEnv,
 542                                    getRequestURI(),
 543                                    rtl::OUString::createFromAscii( "GET" ),
 544                                    aHeaders );
 545
 546             m_xSession->GET( getRequestURI(),
 547                              rStream,
 548                              rHeaderNames,
 549                              rResource,
 550                              DAVRequestEnvironment(
 551                                  getRequestURI(),
 552                                  new DAVAuthListener_Impl( xEnv, m_aURL ),
 553                                  aHeaders, xEnv ) );
 554         }
 555         catch ( DAVException & e )
 556         {
 557             errorCount++;
 558             bRetry = handleException( e, errorCount );
 559             if ( !bRetry )
 560                 throw;
 561         }
 562     }
 563     while ( bRetry );
 564 }
 565
 566 //=========================================================================
 567 void DAVResourceAccess::ABORT()
 568   throw( DAVException )
 569 {
 570     initialize();
 571     m_xSession->ABORT();
 572 }
 573 //=========================================================================
 574 namespace {
 575
 576     void resetInputStream( const uno::Reference< io::XInputStream > & rStream )
 577         throw( DAVException )
 578     {
 579         try
 580         {
 581             uno::Reference< io::XSeekable > xSeekable(
 582                 rStream, uno::UNO_QUERY );
 583             if ( xSeekable.is() )
 584             {
 585                 xSeekable->seek( 0 );
 586                 return;
 587             }
 588         }
 589         catch ( lang::IllegalArgumentException const & )
 590         {
 591         }
 592         catch ( io::IOException const & )
 593         {
 594         }
 595
 596         throw DAVException( DAVException::DAV_INVALID_ARG );
 597     }
 598
 599 } // namespace
 600
 601 //=========================================================================
 602 void DAVResourceAccess::PUT(
 603     const uno::Reference< io::XInputStream > & rStream,
 604     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 605   throw( DAVException )
 606 {
 607     initialize();
 608
 609     // Make stream seekable, if it not. Needed, if request must be retried.
 610     uno::Reference< io::XInputStream > xSeekableStream
 611         = comphelper::OSeekableInputWrapper::CheckSeekableCanWrap(
 612             rStream, m_xSMgr );
 613
 614     int errorCount = 0;
 615     bool bRetry = false;
 616     do
 617     {
 618         if ( bRetry )
 619             resetInputStream( xSeekableStream );
 620
 621         bRetry = false;
 622         try
 623         {
 624             DAVRequestHeaders aHeaders;
 625             getUserRequestHeaders( xEnv,
 626                                    getRequestURI(),
 627                                    rtl::OUString::createFromAscii( "PUT" ),
 628                                    aHeaders );
 629
 630             m_xSession->PUT( getRequestURI(),
 631                              xSeekableStream,
 632                              DAVRequestEnvironment(
 633                                  getRequestURI(),
 634                                  new DAVAuthListener_Impl( xEnv, m_aURL ),
 635                                  aHeaders, xEnv ) );
 636         }
 637         catch ( DAVException & e )
 638         {
 639             errorCount++;
 640             bRetry = handleException( e, errorCount );
 641             if ( !bRetry )
 642                 throw;
 643         }
 644     }
 645     while ( bRetry );
 646 }
 647
 648 //=========================================================================
 649 void DAVResourceAccess::PUT(
 650         const char * buffer, size_t size,
 651         const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 652 throw( DAVException )
 653 {
 654     initialize();
 655
 656     bool bRetry = false;
 657     int errorCount = 0;
 658     do
 659     {
 660         bRetry = false;
 661         try
 662         {
 663             DAVRequestHeaders aHeaders;
 664             getUserRequestHeaders( xEnv,
 665                                    getRequestURI(),
 666                                    rtl::OUString::createFromAscii( "PUT" ),
 667                                    aHeaders );
 668
 669             m_xSession->PUT( getRequestURI(),
 670                              buffer, size,
 671                              DAVRequestEnvironment(
 672                                  getRequestURI(),
 673                                  new DAVAuthListener_Impl( xEnv, m_aURL ),
 674                                  aHeaders, xEnv ) );
 675         }
 676         catch ( DAVException & e )
 677         {
 678             errorCount++;
 679             bRetry = handleException( e, errorCount );
 680             if ( !bRetry )
 681                 throw;
 682         }
 683     }
 684     while ( bRetry );
 685 }
 686
 687 //=========================================================================
 688 uno::Reference< io::XInputStream > DAVResourceAccess::POST(
 689     const rtl::OUString & rContentType,
 690     const rtl::OUString & rReferer,
 691     const uno::Reference< io::XInputStream > & rInputStream,
 692     const uno::Reference< ucb::XCommandEnvironment >& xEnv )
 693   throw ( DAVException )
 694 {
 695     initialize();
 696
 697     // Make stream seekable, if it not. Needed, if request must be retried.
 698     uno::Reference< io::XInputStream > xSeekableStream
 699         = comphelper::OSeekableInputWrapper::CheckSeekableCanWrap(
 700             rInputStream, m_xSMgr );
 701
 702     uno::Reference< io::XInputStream > xStream;
 703     int errorCount = 0;
 704     bool bRetry = false;
 705     do
 706     {
 707         if ( bRetry )
 708         {
 709             resetInputStream( xSeekableStream );
 710             bRetry = false;
 711         }
 712
 713         try
 714         {
 715             DAVRequestHeaders aHeaders;
 716             getUserRequestHeaders( xEnv,
 717                                    getRequestURI(),
 718                                    rtl::OUString::createFromAscii( "POST" ),
 719                                    aHeaders );
 720
 721             xStream = m_xSession->POST( getRequestURI(),
 722                                         rContentType,
 723                                         rReferer,
 724                                         xSeekableStream,
 725                                         DAVRequestEnvironment(
 726                                             getRequestURI(),
 727                                             new DAVAuthListener_Impl( xEnv, m_aURL ),
 728                                             aHeaders, xEnv ) );
 729         }
 730         catch ( DAVException & e )
 731         {
 732             errorCount++;
 733             bRetry = handleException( e, errorCount );
 734             if ( !bRetry )
 735                 throw;
 736
 737             if ( e.getError() == DAVException::DAV_HTTP_REDIRECT )
 738             {
 739                 // #i74980# - Upon POST redirect, do a GET.
 740                 return GET( xEnv );
 741             }
 742         }
 743     }
 744     while ( bRetry );
 745
 746     return xStream;
 747 }
 748
 749 //=========================================================================
 750
 751 void DAVResourceAccess::POST(
 752     const rtl::OUString & rContentType,
 753     const rtl::OUString & rReferer,
 754     const uno::Reference< io::XInputStream > & rInputStream,
 755     uno::Reference< io::XOutputStream > & rOutputStream,
 756     const uno::Reference< ucb::XCommandEnvironment >& xEnv )
 757   throw ( DAVException )
 758 {
 759     initialize();
 760
 761     // Make stream seekable, if it not. Needed, if request must be retried.
 762     uno::Reference< io::XInputStream > xSeekableStream
 763         = comphelper::OSeekableInputWrapper::CheckSeekableCanWrap(
 764             rInputStream, m_xSMgr );
 765
 766     int errorCount = 0;
 767     bool bRetry  = false;
 768     do
 769     {
 770         if ( bRetry )
 771         {
 772             resetInputStream( xSeekableStream );
 773             bRetry = false;
 774         }
 775
 776         try
 777         {
 778             DAVRequestHeaders aHeaders;
 779             getUserRequestHeaders( xEnv,
 780                                    getRequestURI(),
 781                                    rtl::OUString::createFromAscii( "POST" ),
 782                                    aHeaders );
 783
 784             m_xSession->POST( getRequestURI(),
 785                               rContentType,
 786                               rReferer,
 787                               xSeekableStream,
 788                               rOutputStream,
 789                               DAVRequestEnvironment(
 790                                   getRequestURI(),
 791                                   new DAVAuthListener_Impl( xEnv, m_aURL ),
 792                                   aHeaders, xEnv ) );
 793         }
 794         catch ( DAVException & e )
 795         {
 796             errorCount++;
 797             bRetry = handleException( e, errorCount );
 798             if ( !bRetry )
 799                 throw;
 800
 801             if ( e.getError() == DAVException::DAV_HTTP_REDIRECT )
 802             {
 803                 // #i74980# - Upon POST redirect, do a GET.
 804                 GET( rOutputStream, xEnv );
 805                 return;
 806             }
 807         }
 808     }
 809     while ( bRetry );
 810 }
 811
 812 //=========================================================================
 813 void DAVResourceAccess::MKCOL(
 814     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 815   throw( DAVException )
 816 {
 817     initialize();
 818     int errorCount = 0;
 819     bool bRetry;
 820     do
 821     {
 822         bRetry = false;
 823         try
 824         {
 825             DAVRequestHeaders aHeaders;
 826             getUserRequestHeaders( xEnv,
 827                                    getRequestURI(),
 828                                    rtl::OUString::createFromAscii( "MKCOL" ),
 829                                    aHeaders );
 830
 831             m_xSession->MKCOL( getRequestURI(),
 832                                DAVRequestEnvironment(
 833                                    getRequestURI(),
 834                                    new DAVAuthListener_Impl( xEnv, m_aURL ),
 835                                    aHeaders, xEnv ) );
 836         }
 837         catch ( DAVException & e )
 838         {
 839             errorCount++;
 840             bRetry = handleException( e, errorCount );
 841             if ( !bRetry )
 842                 throw;
 843         }
 844     }
 845     while ( bRetry );
 846 }
 847
 848 //=========================================================================
 849 void DAVResourceAccess::COPY(
 850     const ::rtl::OUString & rSourcePath,
 851     const ::rtl::OUString & rDestinationURI,
 852     sal_Bool bOverwrite,
 853     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 854   throw( DAVException )
 855 {
 856     initialize();
 857     int errorCount = 0;
 858     bool bRetry;
 859     do
 860     {
 861         bRetry = false;
 862         try
 863         {
 864             DAVRequestHeaders aHeaders;
 865             getUserRequestHeaders( xEnv,
 866                                    getRequestURI(),
 867                                    rtl::OUString::createFromAscii( "COPY" ),
 868                                    aHeaders );
 869
 870             m_xSession->COPY( rSourcePath,
 871                               rDestinationURI,
 872                               DAVRequestEnvironment(
 873                                   getRequestURI(),
 874                                   new DAVAuthListener_Impl( xEnv, m_aURL ),
 875                                   aHeaders, xEnv ),
 876                               bOverwrite );
 877         }
 878         catch ( DAVException & e )
 879         {
 880             errorCount++;
 881             bRetry = handleException( e, errorCount );
 882             if ( !bRetry )
 883                 throw;
 884         }
 885     }
 886     while ( bRetry );
 887 }
 888
 889 //=========================================================================
 890 void DAVResourceAccess::MOVE(
 891     const ::rtl::OUString & rSourcePath,
 892     const ::rtl::OUString & rDestinationURI,
 893     sal_Bool bOverwrite,
 894     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 895   throw( DAVException )
 896 {
 897     initialize();
 898     int errorCount = 0;
 899     bool bRetry;
 900     do
 901     {
 902         bRetry = false;
 903         try
 904         {
 905             DAVRequestHeaders aHeaders;
 906             getUserRequestHeaders( xEnv,
 907                                    getRequestURI(),
 908                                    rtl::OUString::createFromAscii( "MOVE" ),
 909                                    aHeaders );
 910
 911             m_xSession->MOVE( rSourcePath,
 912                               rDestinationURI,
 913                               DAVRequestEnvironment(
 914                                   getRequestURI(),
 915                                   new DAVAuthListener_Impl( xEnv, m_aURL ),
 916                                   aHeaders, xEnv ),
 917                               bOverwrite );
 918         }
 919         catch ( DAVException & e )
 920         {
 921             errorCount++;
 922             bRetry = handleException( e, errorCount );
 923             if ( !bRetry )
 924                 throw;
 925         }
 926     }
 927     while ( bRetry );
 928 }
 929
 930 //=========================================================================
 931 void DAVResourceAccess::DESTROY(
 932     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 933   throw( DAVException )
 934 {
 935     initialize();
 936
 937     int errorCount = 0;
 938     bool bRetry;
 939     do
 940     {
 941         bRetry = false;
 942         try
 943         {
 944             DAVRequestHeaders aHeaders;
 945             getUserRequestHeaders( xEnv,
 946                                    getRequestURI(),
 947                                    rtl::OUString::createFromAscii(
 948                                        "DESTROY" ),
 949                                    aHeaders );
 950
 951             m_xSession->DESTROY( getRequestURI(),
 952                                  DAVRequestEnvironment(
 953                                      getRequestURI(),
 954                                      new DAVAuthListener_Impl( xEnv, m_aURL ),
 955                                      aHeaders, xEnv ) );
 956         }
 957         catch ( DAVException & e )
 958         {
 959             errorCount++;
 960             bRetry = handleException( e, errorCount );
 961             if ( !bRetry )
 962                 throw;
 963         }
 964     }
 965     while ( bRetry );
 966 }
 967
 968 //=========================================================================
 969 void DAVResourceAccess::LOCK (
 970     ucb::Lock & rLock,
 971     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 972   throw( DAVException )
 973 {
 974     initialize();
 975
 976     DAVRequestHeaders aHeaders;
 977     getUserRequestHeaders( xEnv,
 978             getRequestURI(),
 979             rtl::OUString::createFromAscii( "LOCK" ),
 980             aHeaders );
 981
 982     m_xSession->LOCK( rLock,
 983             DAVRequestEnvironment(
 984                 getRequestURI(),
 985                 new DAVAuthListener_Impl( xEnv, m_aURL ),
 986                 aHeaders, xEnv ) );
 987 }
 988
 989 //=========================================================================
 990 void DAVResourceAccess::UNLOCK (
 991     ucb::Lock & rLock,
 992     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 993   throw( DAVException )
 994 {
 995     initialize();
 996
 997     DAVRequestHeaders aHeaders;
 998     getUserRequestHeaders( xEnv,
 999             getRequestURI(),
1000             rtl::OUString::createFromAscii( "UNLOCK" ),
1001             aHeaders );
1002
1003     m_xSession->UNLOCK( rLock,
1004             DAVRequestEnvironment(
1005                 getRequestURI(),
1006                 new DAVAuthListener_Impl( xEnv, m_aURL ),
1007                 aHeaders, xEnv ) );
1008 }
1009
1010 //=========================================================================
1011 void DAVResourceAccess::setURL( const rtl::OUString & rNewURL )
1012     throw( DAVException )
1013 {
1014     osl::Guard< osl::Mutex > aGuard( m_aMutex );
1015     m_aURL  = rNewURL;
1016     m_aPath = rtl::OUString(); // Next initialize() will create new session.
1017 }
1018
1019 //=========================================================================
1020 // init dav session and path
1021 void DAVResourceAccess::initialize()
1022     throw ( DAVException )
1023 {
1024     osl::Guard< osl::Mutex > aGuard( m_aMutex );
1025     if ( m_aPath.getLength() == 0 )
1026     {
1027         NeonUri aURI( m_aURL );
1028         rtl::OUString aPath( aURI.GetPath() );
1029
1030         /* #134089# - Check URI */
1031         if ( !aPath.getLength() )
1032             throw DAVException( DAVException::DAV_INVALID_ARG );
1033
1034         /* #134089# - Check URI */
1035         if ( !aURI.GetHost().getLength() )
1036             throw DAVException( DAVException::DAV_INVALID_ARG );
1037
1038         if ( !m_xSession.is() || !m_xSession->CanUse( m_aURL ) )
1039         {
1040             m_xSession.clear();
1041
1042             // create new webdav session
1043             m_xSession
1044                 = m_xSessionFactory->createDAVSession( m_aURL, m_xSMgr );
1045
1046             if ( !m_xSession.is() )
1047                 return;
1048         }
1049
1050         // Own URI is needed for redirect cycle detection.
1051         m_aRedirectURIs.push_back( aURI );
1052
1053         // Success.
1054         m_aPath = aPath;
1055
1056         // Not only the path has to be encoded
1057         m_aURL = aURI.GetURI();
1058     }
1059 }
1060
1061 //=========================================================================
1062 const rtl::OUString & DAVResourceAccess::getRequestURI() const
1063 {
1064     OSL_ENSURE( m_xSession.is(),
1065                 "DAVResourceAccess::getRequestURI - Not initialized!" );
1066
1067     // In case a proxy is used we have to use the absolute URI for a request.
1068     if ( m_xSession->UsesProxy() )
1069         return m_aURL;
1070
1071     return m_aPath;
1072 }
1073
1074 //=========================================================================
1075 // static
1076 void DAVResourceAccess::getUserRequestHeaders(
1077     const uno::Reference< ucb::XCommandEnvironment > & xEnv,
1078     const rtl::OUString & rURI,
1079     const rtl::OUString & rMethod,
1080     DAVRequestHeaders & rRequestHeaders )
1081 {
1082     if ( xEnv.is() )
1083     {
1084         uno::Reference< ucb::XWebDAVCommandEnvironment > xDAVEnv(
1085             xEnv, uno::UNO_QUERY );
1086
1087         if ( xDAVEnv.is() )
1088         {
1089             uno::Sequence< beans::NamedValue > aRequestHeaders
1090                 = xDAVEnv->getUserRequestHeaders( rURI, rMethod );
1091
1092             for ( sal_Int32 n = 0; n < aRequestHeaders.getLength(); ++n )
1093             {
1094                 rtl::OUString aValue;
1095                 sal_Bool isString = aRequestHeaders[ n ].Value >>= aValue;
1096
1097                 if ( !isString )
1098                 {
1099                     OSL_ENSURE( isString,
1100                         "DAVResourceAccess::getUserRequestHeaders :"
1101                         "Value is not a string! Ignoring..." );
1102                 }
1103
1104                 rRequestHeaders.push_back( DAVRequestHeader(
1105                     aRequestHeaders[ n ].Name,
1106                     aValue ) );
1107             }
1108         }
1109     }
1110 }
1111
1112 // static
1113 com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > DAVResourceAccess::createCommandEnvironment( void )
1114 {
1115     uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
1116     uno::Reference< task::XInteractionHandler > xInteractionHandler = uno::Reference< task::XInteractionHandler > (
1117             xFactory->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uui.InteractionHandler") ) ), uno::UNO_QUERY );
1118     ucbhelper::CommandEnvironment* pCommandEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, uno::Reference< ucb::XProgressHandler >() );
1119
1120     return uno::Reference< ucb::XCommandEnvironment >( static_cast< ucb::XCommandEnvironment* >( pCommandEnv ), uno::UNO_QUERY );
1121 }
1122
1123
1124 //=========================================================================
1125 sal_Bool DAVResourceAccess::detectRedirectCycle(
1126                                 const rtl::OUString& rRedirectURL )
1127     throw ( DAVException )
1128 {
1129     osl::Guard< osl::Mutex > aGuard( m_aMutex );
1130
1131     NeonUri aUri( rRedirectURL );
1132
1133     std::vector< NeonUri >::const_iterator it  = m_aRedirectURIs.begin();
1134     std::vector< NeonUri >::const_iterator end = m_aRedirectURIs.end();
1135
1136     while ( it != end )
1137     {
1138         if ( aUri == (*it) )
1139             return sal_True;
1140
1141         it++;
1142     }
1143
1144     return sal_False;
1145 }
1146
1147 //=========================================================================
1148 void DAVResourceAccess::resetUri()
1149 {
1150     osl::Guard< osl::Mutex > aGuard( m_aMutex );
1151     if ( m_aRedirectURIs.size() > 0 )
1152     {
1153         std::vector< NeonUri >::const_iterator it  = m_aRedirectURIs.begin();
1154
1155         NeonUri aUri( (*it) );
1156         m_aRedirectURIs.clear();
1157         setURL ( aUri.GetURI() );
1158         initialize();
1159     }
1160 }
1161
1162
1163 //=========================================================================
1164 sal_Bool DAVResourceAccess::handleException( DAVException & e, int errorCount )
1165     throw ( DAVException )
1166 {
1167     switch ( e.getError() )
1168     {
1169     case DAVException::DAV_HTTP_REDIRECT:
1170         if ( !detectRedirectCycle( e.getData() ) )
1171         {
1172             // set new URL and path.
1173             setURL( e.getData() );
1174             initialize();
1175             return sal_True;
1176         }
1177         return sal_False;
1178     // --> tkr #67048# copy & paste images doesn't display.
1179     // if we have a bad connection try again. Up to three times.
1180     case DAVException::DAV_HTTP_ERROR:
1181         // retry up to three times, if not a client-side error.
1182         if ( ( e.getStatus() < 400 || e.getStatus() > 499 ) && errorCount < 3)
1183         {
1184             return sal_True;
1185         }
1186         return sal_False;
1187     // <--
1188     // --> tkr: if connection has said retry then retry!
1189     case DAVException::DAV_HTTP_RETRY:
1190         return sal_True;
1191     // <--
1192     default:
1193         return sal_False; // Abort
1194     }
1195 }