18590a0fdSAndre Fischer /************************************************************** 28590a0fdSAndre Fischer * 38590a0fdSAndre Fischer * Licensed to the Apache Software Foundation (ASF) under one 48590a0fdSAndre Fischer * or more contributor license agreements. See the NOTICE file 58590a0fdSAndre Fischer * distributed with this work for additional information 68590a0fdSAndre Fischer * regarding copyright ownership. The ASF licenses this file 78590a0fdSAndre Fischer * to you under the Apache License, Version 2.0 (the 88590a0fdSAndre Fischer * "License"); you may not use this file except in compliance 98590a0fdSAndre Fischer * with the License. You may obtain a copy of the License at 108590a0fdSAndre Fischer * 118590a0fdSAndre Fischer * http://www.apache.org/licenses/LICENSE-2.0 128590a0fdSAndre Fischer * 138590a0fdSAndre Fischer * Unless required by applicable law or agreed to in writing, 148590a0fdSAndre Fischer * software distributed under the License is distributed on an 158590a0fdSAndre Fischer * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 168590a0fdSAndre Fischer * KIND, either express or implied. See the License for the 178590a0fdSAndre Fischer * specific language governing permissions and limitations 188590a0fdSAndre Fischer * under the License. 198590a0fdSAndre Fischer * 208590a0fdSAndre Fischer *************************************************************/ 218590a0fdSAndre Fischer 228590a0fdSAndre Fischer // MARKER(update_precomp.py): autogen include statement, do not remove 238590a0fdSAndre Fischer #include "precompiled_ucb.hxx" 248590a0fdSAndre Fischer 258590a0fdSAndre Fischer #include <hash_map> 268590a0fdSAndre Fischer #include <vector> 278590a0fdSAndre Fischer #include <string.h> 288590a0fdSAndre Fischer #include <rtl/string.h> 298590a0fdSAndre Fischer #include "comphelper/sequence.hxx" 308590a0fdSAndre Fischer #include "ucbhelper/simplecertificatevalidationrequest.hxx" 318590a0fdSAndre Fischer 328590a0fdSAndre Fischer #include <AprEnv.hxx> 338590a0fdSAndre Fischer #include <apr_strings.h> 348590a0fdSAndre Fischer 358590a0fdSAndre Fischer #include "DAVAuthListener.hxx" 368590a0fdSAndre Fischer #include <SerfTypes.hxx> 378590a0fdSAndre Fischer #include <SerfSession.hxx> 388590a0fdSAndre Fischer #include <SerfUri.hxx> 398590a0fdSAndre Fischer #include <SerfRequestProcessor.hxx> 408590a0fdSAndre Fischer #include <SerfCallbacks.hxx> 418590a0fdSAndre Fischer #include <SerfInputStream.hxx> 428590a0fdSAndre Fischer #include <UCBDeadPropertyValue.hxx> 438590a0fdSAndre Fischer 448590a0fdSAndre Fischer #include <com/sun/star/xml/crypto/XSecurityEnvironment.hpp> 458590a0fdSAndre Fischer #include <com/sun/star/security/XCertificate.hpp> 468590a0fdSAndre Fischer #include <com/sun/star/security/CertificateValidity.hpp> 478590a0fdSAndre Fischer #include <com/sun/star/security/CertificateContainerStatus.hpp> 488590a0fdSAndre Fischer #include <com/sun/star/security/CertificateContainer.hpp> 498590a0fdSAndre Fischer #include <com/sun/star/security/XCertificateContainer.hpp> 508590a0fdSAndre Fischer #include <com/sun/star/ucb/Lock.hpp> 518590a0fdSAndre Fischer #include <com/sun/star/xml/crypto/XSEInitializer.hpp> 528590a0fdSAndre Fischer 538590a0fdSAndre Fischer using namespace com::sun::star; 548590a0fdSAndre Fischer using namespace http_dav_ucp; 558590a0fdSAndre Fischer 56*c58749d7SAndre Fischer 578590a0fdSAndre Fischer // ------------------------------------------------------------------- 588590a0fdSAndre Fischer // static members! 598590a0fdSAndre Fischer bool SerfSession::m_bGlobalsInited = false; 608590a0fdSAndre Fischer osl::Mutex SerfSession::m_aGlobalMutex; 618590a0fdSAndre Fischer //SerfLockStore SerfSession::m_aSerfLockStore; 628590a0fdSAndre Fischer 638590a0fdSAndre Fischer // ------------------------------------------------------------------- 648590a0fdSAndre Fischer // Constructor 658590a0fdSAndre Fischer // ------------------------------------------------------------------- 668590a0fdSAndre Fischer SerfSession::SerfSession( 678590a0fdSAndre Fischer const rtl::Reference< DAVSessionFactory > & rSessionFactory, 688590a0fdSAndre Fischer const rtl::OUString& inUri, 698590a0fdSAndre Fischer const ucbhelper::InternetProxyDecider & rProxyDecider ) 708590a0fdSAndre Fischer throw ( DAVException ) 718590a0fdSAndre Fischer : DAVSession( rSessionFactory ) 728590a0fdSAndre Fischer , m_aMutex() 738590a0fdSAndre Fischer , m_aUri( inUri ) 748590a0fdSAndre Fischer , m_aProxyName() 758590a0fdSAndre Fischer , m_nProxyPort( 0 ) 768590a0fdSAndre Fischer , m_pSerfConnection( 0 ) 778590a0fdSAndre Fischer , m_pSerfContext( 0 ) 788590a0fdSAndre Fischer , m_bIsHeadRequestInProgress( false ) 798590a0fdSAndre Fischer , m_rProxyDecider( rProxyDecider ) 808590a0fdSAndre Fischer , m_aEnv() 818590a0fdSAndre Fischer { 828590a0fdSAndre Fischer m_pSerfContext = serf_context_create( getAprPool() ); 838590a0fdSAndre Fischer 848590a0fdSAndre Fischer m_pSerfBucket_Alloc = serf_bucket_allocator_create( getAprPool(), NULL, NULL ); 858590a0fdSAndre Fischer } 868590a0fdSAndre Fischer 878590a0fdSAndre Fischer // ------------------------------------------------------------------- 888590a0fdSAndre Fischer // Destructor 898590a0fdSAndre Fischer // ------------------------------------------------------------------- 908590a0fdSAndre Fischer SerfSession::~SerfSession( ) 918590a0fdSAndre Fischer { 928590a0fdSAndre Fischer if ( m_pSerfConnection ) 938590a0fdSAndre Fischer { 948590a0fdSAndre Fischer serf_connection_close( m_pSerfConnection ); 958590a0fdSAndre Fischer m_pSerfConnection = 0; 968590a0fdSAndre Fischer } 978590a0fdSAndre Fischer } 988590a0fdSAndre Fischer 998590a0fdSAndre Fischer // ------------------------------------------------------------------- 1008590a0fdSAndre Fischer void SerfSession::Init( const DAVRequestEnvironment & rEnv ) 1018590a0fdSAndre Fischer throw ( DAVException ) 1028590a0fdSAndre Fischer { 1038590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 1048590a0fdSAndre Fischer m_aEnv = rEnv; 1058590a0fdSAndre Fischer Init(); 1068590a0fdSAndre Fischer } 1078590a0fdSAndre Fischer 1088590a0fdSAndre Fischer // ------------------------------------------------------------------- 1098590a0fdSAndre Fischer void SerfSession::Init() 1108590a0fdSAndre Fischer throw ( DAVException ) 1118590a0fdSAndre Fischer { 1128590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 1138590a0fdSAndre Fischer 1148590a0fdSAndre Fischer bool bCreateNewSession = false; 1158590a0fdSAndre Fischer 1168590a0fdSAndre Fischer if ( m_pSerfConnection == 0 ) 1178590a0fdSAndre Fischer { 1188590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGlobalGuard( m_aGlobalMutex ); 1198590a0fdSAndre Fischer // <-- 1208590a0fdSAndre Fischer if ( !m_bGlobalsInited ) 1218590a0fdSAndre Fischer { 1228590a0fdSAndre Fischer // TODO - figure out, if anything has to be done here 1238590a0fdSAndre Fischer m_bGlobalsInited = true; 1248590a0fdSAndre Fischer } 1258590a0fdSAndre Fischer 1268590a0fdSAndre Fischer const ucbhelper::InternetProxyServer & rProxyCfg = getProxySettings(); 1278590a0fdSAndre Fischer 1288590a0fdSAndre Fischer m_aProxyName = rProxyCfg.aName; 1298590a0fdSAndre Fischer m_nProxyPort = rProxyCfg.nPort; 1308590a0fdSAndre Fischer 1318590a0fdSAndre Fischer // Not yet initialized. Create new session. 1328590a0fdSAndre Fischer bCreateNewSession = true; 1338590a0fdSAndre Fischer } 1348590a0fdSAndre Fischer else 1358590a0fdSAndre Fischer { 1368590a0fdSAndre Fischer const ucbhelper::InternetProxyServer & rProxyCfg = getProxySettings(); 1378590a0fdSAndre Fischer 1388590a0fdSAndre Fischer if ( ( rProxyCfg.aName != m_aProxyName ) 1398590a0fdSAndre Fischer || ( rProxyCfg.nPort != m_nProxyPort ) ) 1408590a0fdSAndre Fischer { 1418590a0fdSAndre Fischer m_aProxyName = rProxyCfg.aName; 1428590a0fdSAndre Fischer m_nProxyPort = rProxyCfg.nPort; 1438590a0fdSAndre Fischer 1448590a0fdSAndre Fischer // new session needed, destroy old first 1458590a0fdSAndre Fischer serf_connection_close( m_pSerfConnection ); 1468590a0fdSAndre Fischer m_pSerfConnection = 0; 1478590a0fdSAndre Fischer bCreateNewSession = true; 1488590a0fdSAndre Fischer } 1498590a0fdSAndre Fischer } 1508590a0fdSAndre Fischer 1518590a0fdSAndre Fischer if ( bCreateNewSession ) 1528590a0fdSAndre Fischer { 1538590a0fdSAndre Fischer // TODO - close_connection callback 1548590a0fdSAndre Fischer apr_status_t status = serf_connection_create2( &m_pSerfConnection, 1558590a0fdSAndre Fischer m_pSerfContext, 1568590a0fdSAndre Fischer *(m_aUri.getAprUri()), 1578590a0fdSAndre Fischer Serf_ConnectSetup, this, 1588590a0fdSAndre Fischer 0 /* close connection callback */, 0 /* close connection baton */, 1598590a0fdSAndre Fischer getAprPool() ); 1608590a0fdSAndre Fischer 1618590a0fdSAndre Fischer if ( m_pSerfConnection == 0 ||status != APR_SUCCESS ) 1628590a0fdSAndre Fischer { 1638590a0fdSAndre Fischer throw DAVException( DAVException::DAV_SESSION_CREATE, 1648590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( m_aUri.GetHost(), m_aUri.GetPort() ) ); 1658590a0fdSAndre Fischer } 1668590a0fdSAndre Fischer 1678590a0fdSAndre Fischer // Register the session with the lock store 1688590a0fdSAndre Fischer // m_aSerfLockStore.registerSession( m_pSerfConnection ); 1698590a0fdSAndre Fischer 1708590a0fdSAndre Fischer if ( m_aProxyName.getLength() ) 1718590a0fdSAndre Fischer { 1728590a0fdSAndre Fischer apr_sockaddr_t *proxy_address = NULL; 1738590a0fdSAndre Fischer const apr_status_t status = apr_sockaddr_info_get( &proxy_address, 1748590a0fdSAndre Fischer rtl::OUStringToOString( m_aProxyName, RTL_TEXTENCODING_UTF8 ), 1758590a0fdSAndre Fischer APR_UNSPEC, 1768590a0fdSAndre Fischer static_cast<apr_port_t>(m_nProxyPort), 1778590a0fdSAndre Fischer 0, getAprPool() ); 1788590a0fdSAndre Fischer 1798590a0fdSAndre Fischer if ( status != APR_SUCCESS ) 1808590a0fdSAndre Fischer { 1818590a0fdSAndre Fischer throw DAVException( DAVException::DAV_SESSION_CREATE, 1828590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( m_aUri.GetHost(), m_aUri.GetPort() ) ); 1838590a0fdSAndre Fischer } 1848590a0fdSAndre Fischer 1858590a0fdSAndre Fischer serf_config_proxy( m_pSerfContext, proxy_address ); 1868590a0fdSAndre Fischer } 1878590a0fdSAndre Fischer 1888590a0fdSAndre Fischer 189307c6619SOliver-Rainer Wittmann serf_config_credentials_callback( m_pSerfContext, Serf_Credentials ); 1908590a0fdSAndre Fischer } 1918590a0fdSAndre Fischer } 1928590a0fdSAndre Fischer 1938590a0fdSAndre Fischer apr_pool_t* SerfSession::getAprPool() 1948590a0fdSAndre Fischer { 1958590a0fdSAndre Fischer return apr_environment::AprEnv::getAprEnv()->getAprPool(); 1968590a0fdSAndre Fischer } 1978590a0fdSAndre Fischer 1988590a0fdSAndre Fischer serf_bucket_alloc_t* SerfSession::getSerfBktAlloc() 1998590a0fdSAndre Fischer { 2008590a0fdSAndre Fischer return m_pSerfBucket_Alloc; 2018590a0fdSAndre Fischer } 2028590a0fdSAndre Fischer 2038590a0fdSAndre Fischer serf_context_t* SerfSession::getSerfContext() 2048590a0fdSAndre Fischer { 2058590a0fdSAndre Fischer return m_pSerfContext; 2068590a0fdSAndre Fischer } 2078590a0fdSAndre Fischer 2088590a0fdSAndre Fischer SerfConnection* SerfSession::getSerfConnection() 2098590a0fdSAndre Fischer { 2108590a0fdSAndre Fischer return m_pSerfConnection; 2118590a0fdSAndre Fischer } 2128590a0fdSAndre Fischer 2138590a0fdSAndre Fischer bool SerfSession::isHeadRequestInProgress() 2148590a0fdSAndre Fischer { 2158590a0fdSAndre Fischer return m_bIsHeadRequestInProgress; 2168590a0fdSAndre Fischer } 2178590a0fdSAndre Fischer 2188590a0fdSAndre Fischer bool SerfSession::isSSLNeeded() 2198590a0fdSAndre Fischer { 2208590a0fdSAndre Fischer return m_aUri.GetScheme().equalsIgnoreAsciiCase( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "https" ) ) ); 2218590a0fdSAndre Fischer } 2228590a0fdSAndre Fischer 2238590a0fdSAndre Fischer char* SerfSession::getHostinfo() 2248590a0fdSAndre Fischer { 2258590a0fdSAndre Fischer return m_aUri.getAprUri()->hostinfo; 2268590a0fdSAndre Fischer } 2278590a0fdSAndre Fischer 2288590a0fdSAndre Fischer 2298590a0fdSAndre Fischer // ------------------------------------------------------------------- 2308590a0fdSAndre Fischer // virtual 2318590a0fdSAndre Fischer sal_Bool SerfSession::CanUse( const rtl::OUString & inUri ) 2328590a0fdSAndre Fischer { 2338590a0fdSAndre Fischer try 2348590a0fdSAndre Fischer { 2358590a0fdSAndre Fischer SerfUri theUri( inUri ); 2368590a0fdSAndre Fischer if ( ( theUri.GetPort() == m_aUri.GetPort() ) && 2378590a0fdSAndre Fischer ( theUri.GetHost() == m_aUri.GetHost() ) && 2388590a0fdSAndre Fischer ( theUri.GetScheme() == m_aUri.GetScheme() ) ) 2398590a0fdSAndre Fischer { 2408590a0fdSAndre Fischer return sal_True; 2418590a0fdSAndre Fischer } 2428590a0fdSAndre Fischer } 2438590a0fdSAndre Fischer catch ( DAVException const & ) 2448590a0fdSAndre Fischer { 2458590a0fdSAndre Fischer return sal_False; 2468590a0fdSAndre Fischer } 2478590a0fdSAndre Fischer return sal_False; 2488590a0fdSAndre Fischer } 2498590a0fdSAndre Fischer 2508590a0fdSAndre Fischer // ------------------------------------------------------------------- 2518590a0fdSAndre Fischer // virtual 2528590a0fdSAndre Fischer sal_Bool SerfSession::UsesProxy() 2538590a0fdSAndre Fischer { 2548590a0fdSAndre Fischer Init(); 2558590a0fdSAndre Fischer return ( m_aProxyName.getLength() > 0 ); 2568590a0fdSAndre Fischer } 2578590a0fdSAndre Fischer 2588590a0fdSAndre Fischer apr_status_t SerfSession::setupSerfConnection( apr_socket_t * inAprSocket, 2598590a0fdSAndre Fischer serf_bucket_t **outSerfInputBucket, 2608590a0fdSAndre Fischer serf_bucket_t **outSerfOutputBucket, 2618590a0fdSAndre Fischer apr_pool_t* /*inAprPool*/ ) 2628590a0fdSAndre Fischer { 2638590a0fdSAndre Fischer serf_bucket_t *tmpInputBkt; 2648590a0fdSAndre Fischer tmpInputBkt = serf_context_bucket_socket_create( getSerfContext(), 2658590a0fdSAndre Fischer inAprSocket, 2668590a0fdSAndre Fischer getSerfBktAlloc() ); 2678590a0fdSAndre Fischer 2688590a0fdSAndre Fischer if ( isSSLNeeded() ) 2698590a0fdSAndre Fischer { 2708590a0fdSAndre Fischer tmpInputBkt = serf_bucket_ssl_decrypt_create( tmpInputBkt, 2718590a0fdSAndre Fischer 0, 2728590a0fdSAndre Fischer getSerfBktAlloc() ); 273*c58749d7SAndre Fischer /** Set the callback that is called to authenticate the 274*c58749d7SAndre Fischer certifcate (chain). 275*c58749d7SAndre Fischer */ 276*c58749d7SAndre Fischer serf_ssl_server_cert_chain_callback_set( 277*c58749d7SAndre Fischer serf_bucket_ssl_decrypt_context_get(tmpInputBkt), 278*c58749d7SAndre Fischer Serf_CertificateChainValidation, 279*c58749d7SAndre Fischer this); 2808590a0fdSAndre Fischer serf_ssl_set_hostname( serf_bucket_ssl_decrypt_context_get( tmpInputBkt ), 2818590a0fdSAndre Fischer getHostinfo() ); 2828590a0fdSAndre Fischer 2838590a0fdSAndre Fischer *outSerfOutputBucket = serf_bucket_ssl_encrypt_create( *outSerfOutputBucket, 2848590a0fdSAndre Fischer serf_bucket_ssl_decrypt_context_get( tmpInputBkt ), 2858590a0fdSAndre Fischer getSerfBktAlloc() ); 2868590a0fdSAndre Fischer } 2878590a0fdSAndre Fischer 2888590a0fdSAndre Fischer *outSerfInputBucket = tmpInputBkt; 2898590a0fdSAndre Fischer 2908590a0fdSAndre Fischer return APR_SUCCESS; 2918590a0fdSAndre Fischer } 2928590a0fdSAndre Fischer 293fb7f54d2SOliver-Rainer Wittmann apr_status_t SerfSession::provideSerfCredentials( bool bGiveProvidedCredentialsASecondTry, 294fb7f54d2SOliver-Rainer Wittmann char ** outUsername, 295307c6619SOliver-Rainer Wittmann char ** outPassword, 296307c6619SOliver-Rainer Wittmann serf_request_t * /*inRequest*/, 297307c6619SOliver-Rainer Wittmann int /*inCode*/, 298307c6619SOliver-Rainer Wittmann const char *inAuthProtocol, 299307c6619SOliver-Rainer Wittmann const char *inRealm, 3008590a0fdSAndre Fischer apr_pool_t *inAprPool ) 3018590a0fdSAndre Fischer { 3028590a0fdSAndre Fischer DAVAuthListener * pListener = getRequestEnvironment().m_xAuthListener.get(); 3038590a0fdSAndre Fischer if ( !pListener ) 3048590a0fdSAndre Fischer { 3058590a0fdSAndre Fischer // abort 3068590a0fdSAndre Fischer return SERF_ERROR_AUTHN_FAILED; 3078590a0fdSAndre Fischer } 3088590a0fdSAndre Fischer 3098590a0fdSAndre Fischer rtl::OUString theUserName; 3108590a0fdSAndre Fischer rtl::OUString thePassWord; 3118590a0fdSAndre Fischer try 3128590a0fdSAndre Fischer { 3138590a0fdSAndre Fischer SerfUri uri( getRequestEnvironment().m_aRequestURI ); 3148590a0fdSAndre Fischer rtl::OUString aUserInfo( uri.GetUserInfo() ); 3158590a0fdSAndre Fischer if ( aUserInfo.getLength() ) 3168590a0fdSAndre Fischer { 3178590a0fdSAndre Fischer sal_Int32 nPos = aUserInfo.indexOf( '@' ); 3188590a0fdSAndre Fischer if ( nPos == -1 ) 3198590a0fdSAndre Fischer { 3208590a0fdSAndre Fischer theUserName = aUserInfo; 3218590a0fdSAndre Fischer } 3228590a0fdSAndre Fischer else 3238590a0fdSAndre Fischer { 3248590a0fdSAndre Fischer theUserName = aUserInfo.copy( 0, nPos ); 3258590a0fdSAndre Fischer thePassWord = aUserInfo.copy( nPos + 1 ); 3268590a0fdSAndre Fischer } 3278590a0fdSAndre Fischer } 3288590a0fdSAndre Fischer } 3298590a0fdSAndre Fischer catch ( DAVException const & ) 3308590a0fdSAndre Fischer { 3318590a0fdSAndre Fischer // abort 3328590a0fdSAndre Fischer return SERF_ERROR_AUTHN_FAILED; 3338590a0fdSAndre Fischer } 3348590a0fdSAndre Fischer 3358590a0fdSAndre Fischer const bool bCanUseSystemCreds = ( ( strcasecmp( inAuthProtocol, "NTLM" ) == 0 ) || 3368590a0fdSAndre Fischer ( strcasecmp( inAuthProtocol, "Negotiate" ) == 0 ) ); 3378590a0fdSAndre Fischer 3388590a0fdSAndre Fischer int theRetVal = pListener->authenticate( rtl::OUString::createFromAscii( inRealm ), 3398590a0fdSAndre Fischer getHostName(), 3408590a0fdSAndre Fischer theUserName, 3418590a0fdSAndre Fischer thePassWord, 342fb7f54d2SOliver-Rainer Wittmann bCanUseSystemCreds, 343fb7f54d2SOliver-Rainer Wittmann bGiveProvidedCredentialsASecondTry ? sal_False : sal_True ); 3448590a0fdSAndre Fischer 3458590a0fdSAndre Fischer if ( theRetVal == 0 ) 3468590a0fdSAndre Fischer { 3478590a0fdSAndre Fischer *outUsername = apr_pstrdup( inAprPool, rtl::OUStringToOString( theUserName, RTL_TEXTENCODING_UTF8 ) ); 3488590a0fdSAndre Fischer *outPassword = apr_pstrdup( inAprPool, rtl::OUStringToOString( thePassWord, RTL_TEXTENCODING_UTF8 ) ); 3498590a0fdSAndre Fischer } 3508590a0fdSAndre Fischer 3518590a0fdSAndre Fischer return theRetVal != 0 ? SERF_ERROR_AUTHN_FAILED : APR_SUCCESS; 3528590a0fdSAndre Fischer } 3538590a0fdSAndre Fischer 3548590a0fdSAndre Fischer namespace { 3558590a0fdSAndre Fischer // ------------------------------------------------------------------- 3568590a0fdSAndre Fischer // Helper function 3578590a0fdSAndre Fischer ::rtl::OUString GetHostnamePart( const ::rtl::OUString& _rRawString ) 3588590a0fdSAndre Fischer { 3598590a0fdSAndre Fischer ::rtl::OUString sPart; 3608590a0fdSAndre Fischer ::rtl::OUString sPartId = ::rtl::OUString::createFromAscii( "CN=" ); 3618590a0fdSAndre Fischer sal_Int32 nContStart = _rRawString.indexOf( sPartId ); 3628590a0fdSAndre Fischer if ( nContStart != -1 ) 3638590a0fdSAndre Fischer { 3648590a0fdSAndre Fischer nContStart = nContStart + sPartId.getLength(); 3658590a0fdSAndre Fischer sal_Int32 nContEnd 3668590a0fdSAndre Fischer = _rRawString.indexOf( sal_Unicode( ',' ), nContStart ); 3678590a0fdSAndre Fischer sPart = _rRawString.copy( nContStart, nContEnd - nContStart ); 3688590a0fdSAndre Fischer } 3698590a0fdSAndre Fischer return sPart; 3708590a0fdSAndre Fischer } 3718590a0fdSAndre Fischer } // namespace 3728590a0fdSAndre Fischer 3738590a0fdSAndre Fischer 374*c58749d7SAndre Fischer apr_status_t SerfSession::verifySerfCertificateChain ( 375*c58749d7SAndre Fischer int, 376*c58749d7SAndre Fischer const char** pCertificateChainBase64Encoded, 377*c58749d7SAndre Fischer const int nCertificateChainLength) 378*c58749d7SAndre Fischer { 379*c58749d7SAndre Fischer // Check arguments. 380*c58749d7SAndre Fischer if (pCertificateChainBase64Encoded == NULL || nCertificateChainLength<=0) 3818590a0fdSAndre Fischer { 382*c58749d7SAndre Fischer OSL_ASSERT(pCertificateChainBase64Encoded != NULL); 383*c58749d7SAndre Fischer OSL_ASSERT(nCertificateChainLength>0); 3848590a0fdSAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 3858590a0fdSAndre Fischer } 3868590a0fdSAndre Fischer 387*c58749d7SAndre Fischer // Create some crypto objects to decode and handle the base64 388*c58749d7SAndre Fischer // encoded certificate chain. 3898590a0fdSAndre Fischer uno::Reference< xml::crypto::XSEInitializer > xSEInitializer; 390*c58749d7SAndre Fischer uno::Reference< security::XCertificateContainer > xCertificateContainer; 391*c58749d7SAndre Fischer uno::Reference< xml::crypto::XXMLSecurityContext > xSecurityContext; 392*c58749d7SAndre Fischer uno::Reference< xml::crypto::XSecurityEnvironment > xSecurityEnv; 3938590a0fdSAndre Fischer try 3948590a0fdSAndre Fischer { 395*c58749d7SAndre Fischer // Create a certificate container. 396*c58749d7SAndre Fischer xCertificateContainer = uno::Reference< security::XCertificateContainer >( 397*c58749d7SAndre Fischer getMSF()->createInstance( 398*c58749d7SAndre Fischer rtl::OUString::createFromAscii( 399*c58749d7SAndre Fischer "com.sun.star.security.CertificateContainer" ) ), 400*c58749d7SAndre Fischer uno::UNO_QUERY_THROW); 401*c58749d7SAndre Fischer 4028590a0fdSAndre Fischer xSEInitializer = uno::Reference< xml::crypto::XSEInitializer >( 4038590a0fdSAndre Fischer getMSF()->createInstance( 4048590a0fdSAndre Fischer rtl::OUString::createFromAscii( "com.sun.star.xml.crypto.SEInitializer" ) ), 405*c58749d7SAndre Fischer uno::UNO_QUERY_THROW); 406*c58749d7SAndre Fischer 407*c58749d7SAndre Fischer xSecurityContext = xSEInitializer->createSecurityContext( rtl::OUString() ); 408*c58749d7SAndre Fischer if (xSecurityContext.is()) 409*c58749d7SAndre Fischer xSecurityEnv = xSecurityContext->getSecurityEnvironment(); 410*c58749d7SAndre Fischer 411*c58749d7SAndre Fischer if ( ! xSecurityContext.is() || ! xSecurityEnv.is()) 412*c58749d7SAndre Fischer { 413*c58749d7SAndre Fischer // Do we have to dispose xSEInitializer or xCertificateContainer? 414*c58749d7SAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 415*c58749d7SAndre Fischer } 4168590a0fdSAndre Fischer } 417*c58749d7SAndre Fischer catch ( uno::Exception const &) 4188590a0fdSAndre Fischer { 4198590a0fdSAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 420*c58749d7SAndre Fischer } 4218590a0fdSAndre Fischer 422*c58749d7SAndre Fischer // Decode the server certificate. 423*c58749d7SAndre Fischer uno::Reference< security::XCertificate > xServerCertificate( 4248590a0fdSAndre Fischer xSecurityEnv->createCertificateFromAscii( 425*c58749d7SAndre Fischer rtl::OUString::createFromAscii(pCertificateChainBase64Encoded[0]))); 426*c58749d7SAndre Fischer if ( ! xServerCertificate.is()) 427*c58749d7SAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 4288590a0fdSAndre Fischer 429*c58749d7SAndre Fischer // Get the subject from the server certificate. 430*c58749d7SAndre Fischer ::rtl::OUString sServerCertificateSubject (xServerCertificate->getSubjectName()); 431*c58749d7SAndre Fischer sal_Int32 nIndex = 0; 432*c58749d7SAndre Fischer while (nIndex >= 0) 4338590a0fdSAndre Fischer { 434*c58749d7SAndre Fischer const ::rtl::OUString sToken (sServerCertificateSubject.getToken(0, ',', nIndex)); 435*c58749d7SAndre Fischer if (sToken.compareToAscii("CN=", 3) == 0) 436*c58749d7SAndre Fischer { 437*c58749d7SAndre Fischer sServerCertificateSubject = sToken.copy(3); 4388590a0fdSAndre Fischer break; 439*c58749d7SAndre Fischer } 440*c58749d7SAndre Fischer else if (sToken.compareToAscii(" CN=", 4) == 0) 441*c58749d7SAndre Fischer { 442*c58749d7SAndre Fischer sServerCertificateSubject = sToken.copy(4); 443*c58749d7SAndre Fischer break; 444*c58749d7SAndre Fischer } 445*c58749d7SAndre Fischer } 4468590a0fdSAndre Fischer 447*c58749d7SAndre Fischer // When the certificate container already contains a (trusted) 448*c58749d7SAndre Fischer // entry for the server then we do not have to authenticate any 449*c58749d7SAndre Fischer // certificate. 450*c58749d7SAndre Fischer const security::CertificateContainerStatus eStatus ( 451*c58749d7SAndre Fischer xCertificateContainer->hasCertificate( 452*c58749d7SAndre Fischer getHostName(), sServerCertificateSubject ) ); 453*c58749d7SAndre Fischer if (eStatus != security::CertificateContainerStatus_NOCERT) 454*c58749d7SAndre Fischer { 455*c58749d7SAndre Fischer return eStatus == security::CertificateContainerStatus_TRUSTED 456*c58749d7SAndre Fischer ? APR_SUCCESS 457*c58749d7SAndre Fischer : SERF_SSL_CERT_UNKNOWN_FAILURE; 458*c58749d7SAndre Fischer } 4598590a0fdSAndre Fischer 460*c58749d7SAndre Fischer // The shortcut failed, so try to verify the whole chain. This is 461*c58749d7SAndre Fischer // done outside the isDomainMatch() block because the result is 462*c58749d7SAndre Fischer // used by the interaction handler. 463*c58749d7SAndre Fischer std::vector< uno::Reference< security::XCertificate > > aChain; 464*c58749d7SAndre Fischer for (int nIndex=1; nIndex<nCertificateChainLength; ++nIndex) 465*c58749d7SAndre Fischer { 466*c58749d7SAndre Fischer uno::Reference< security::XCertificate > xCertificate( 4678590a0fdSAndre Fischer xSecurityEnv->createCertificateFromAscii( 468*c58749d7SAndre Fischer rtl::OUString::createFromAscii(pCertificateChainBase64Encoded[nIndex]))); 469*c58749d7SAndre Fischer if ( ! xCertificate.is()) 470*c58749d7SAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 471*c58749d7SAndre Fischer aChain.push_back(xCertificate); 4728590a0fdSAndre Fischer } 473*c58749d7SAndre Fischer const sal_Int64 nVerificationResult (xSecurityEnv->verifyCertificate( 474*c58749d7SAndre Fischer xServerCertificate, 475*c58749d7SAndre Fischer ::comphelper::containerToSequence(aChain))); 4768590a0fdSAndre Fischer 477*c58749d7SAndre Fischer // When the certificate matches the host name then we can use the 478*c58749d7SAndre Fischer // result of the verification. 479*c58749d7SAndre Fischer if (isDomainMatch(sServerCertificateSubject)) 4808590a0fdSAndre Fischer { 481*c58749d7SAndre Fischer 482*c58749d7SAndre Fischer if (nVerificationResult == 0) 483*c58749d7SAndre Fischer { 484*c58749d7SAndre Fischer // Certificate (chain) is valid. 485*c58749d7SAndre Fischer xCertificateContainer->addCertificate(getHostName(), sServerCertificateSubject, sal_True); 4868590a0fdSAndre Fischer return APR_SUCCESS; 487*c58749d7SAndre Fischer } 488*c58749d7SAndre Fischer else if ((nVerificationResult & security::CertificateValidity::CHAIN_INCOMPLETE) != 0) 489*c58749d7SAndre Fischer { 490*c58749d7SAndre Fischer // We do not have enough information for verification, 491*c58749d7SAndre Fischer // neither automatically (as we just discovered) nor 492*c58749d7SAndre Fischer // manually (so there is no point in showing any dialog.) 493*c58749d7SAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 494*c58749d7SAndre Fischer } 495*c58749d7SAndre Fischer else if ((nVerificationResult & 496*c58749d7SAndre Fischer (security::CertificateValidity::INVALID | security::CertificateValidity::REVOKED)) != 0) 497*c58749d7SAndre Fischer { 498*c58749d7SAndre Fischer // Certificate (chain) is invalid. 499*c58749d7SAndre Fischer xCertificateContainer->addCertificate(getHostName(), sServerCertificateSubject, sal_False); 500*c58749d7SAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 501*c58749d7SAndre Fischer } 502*c58749d7SAndre Fischer else 503*c58749d7SAndre Fischer { 504*c58749d7SAndre Fischer // For all other we have to ask the user. 505*c58749d7SAndre Fischer } 5068590a0fdSAndre Fischer } 5078590a0fdSAndre Fischer 508*c58749d7SAndre Fischer // We have not been able to automatically verify (or falsify) the 509*c58749d7SAndre Fischer // certificate chain. To resolve this we have to ask the user. 5108590a0fdSAndre Fischer const uno::Reference< ucb::XCommandEnvironment > xEnv( getRequestEnvironment().m_xEnv ); 5118590a0fdSAndre Fischer if ( xEnv.is() ) 5128590a0fdSAndre Fischer { 5138590a0fdSAndre Fischer uno::Reference< task::XInteractionHandler > xIH( xEnv->getInteractionHandler() ); 5148590a0fdSAndre Fischer if ( xIH.is() ) 5158590a0fdSAndre Fischer { 5168590a0fdSAndre Fischer rtl::Reference< ucbhelper::SimpleCertificateValidationRequest > 5178590a0fdSAndre Fischer xRequest( new ucbhelper::SimpleCertificateValidationRequest( 518*c58749d7SAndre Fischer static_cast<sal_Int32>(nVerificationResult), xServerCertificate, getHostName() ) ); 5198590a0fdSAndre Fischer xIH->handle( xRequest.get() ); 5208590a0fdSAndre Fischer 5218590a0fdSAndre Fischer rtl::Reference< ucbhelper::InteractionContinuation > xSelection 5228590a0fdSAndre Fischer = xRequest->getSelection(); 5238590a0fdSAndre Fischer 5248590a0fdSAndre Fischer if ( xSelection.is() ) 5258590a0fdSAndre Fischer { 5268590a0fdSAndre Fischer uno::Reference< task::XInteractionApprove > xApprove( 5278590a0fdSAndre Fischer xSelection.get(), uno::UNO_QUERY ); 5288590a0fdSAndre Fischer if ( xApprove.is() ) 5298590a0fdSAndre Fischer { 530*c58749d7SAndre Fischer xCertificateContainer->addCertificate( getHostName(), sServerCertificateSubject, sal_True ); 5318590a0fdSAndre Fischer return APR_SUCCESS; 5328590a0fdSAndre Fischer } 5338590a0fdSAndre Fischer else 5348590a0fdSAndre Fischer { 5358590a0fdSAndre Fischer // Don't trust cert 536*c58749d7SAndre Fischer xCertificateContainer->addCertificate( getHostName(), sServerCertificateSubject, sal_False ); 5378590a0fdSAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 5388590a0fdSAndre Fischer } 5398590a0fdSAndre Fischer } 5408590a0fdSAndre Fischer } 5418590a0fdSAndre Fischer else 5428590a0fdSAndre Fischer { 5438590a0fdSAndre Fischer // Don't trust cert 544*c58749d7SAndre Fischer xCertificateContainer->addCertificate( getHostName(), sServerCertificateSubject, sal_False ); 5458590a0fdSAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 5468590a0fdSAndre Fischer } 5478590a0fdSAndre Fischer } 548*c58749d7SAndre Fischer 5498590a0fdSAndre Fischer return SERF_SSL_CERT_UNKNOWN_FAILURE; 5508590a0fdSAndre Fischer } 5518590a0fdSAndre Fischer 5528590a0fdSAndre Fischer serf_bucket_t* SerfSession::acceptSerfResponse( serf_request_t * inSerfRequest, 5538590a0fdSAndre Fischer serf_bucket_t * inSerfStreamBucket, 5548590a0fdSAndre Fischer apr_pool_t* /*inAprPool*/ ) 5558590a0fdSAndre Fischer { 5568590a0fdSAndre Fischer // get the per-request bucket allocator 5578590a0fdSAndre Fischer serf_bucket_alloc_t* SerfBktAlloc = serf_request_get_alloc( inSerfRequest ); 5588590a0fdSAndre Fischer 5598590a0fdSAndre Fischer // create a barrier bucket so the response doesn't eat us! 5608590a0fdSAndre Fischer serf_bucket_t *responseBkt = serf_bucket_barrier_create( inSerfStreamBucket, 5618590a0fdSAndre Fischer SerfBktAlloc ); 5628590a0fdSAndre Fischer 5638590a0fdSAndre Fischer // create response bucket 5648590a0fdSAndre Fischer responseBkt = serf_bucket_response_create( responseBkt, 5658590a0fdSAndre Fischer SerfBktAlloc ); 5668590a0fdSAndre Fischer 5678590a0fdSAndre Fischer if ( isHeadRequestInProgress() ) 5688590a0fdSAndre Fischer { 5698590a0fdSAndre Fischer // advise the response bucket that this was from a HEAD request and that it should not expect to see a response body. 5708590a0fdSAndre Fischer serf_bucket_response_set_head( responseBkt ); 5718590a0fdSAndre Fischer } 5728590a0fdSAndre Fischer 5738590a0fdSAndre Fischer return responseBkt; 5748590a0fdSAndre Fischer } 5758590a0fdSAndre Fischer 5768590a0fdSAndre Fischer // ------------------------------------------------------------------- 5778590a0fdSAndre Fischer // PROPFIND - allprop & named 5788590a0fdSAndre Fischer // ------------------------------------------------------------------- 5798590a0fdSAndre Fischer void SerfSession::PROPFIND( const rtl::OUString & inPath, 5808590a0fdSAndre Fischer const Depth inDepth, 5818590a0fdSAndre Fischer const std::vector< rtl::OUString > & inPropNames, 5828590a0fdSAndre Fischer std::vector< DAVResource > & ioResources, 5838590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 5848590a0fdSAndre Fischer throw ( DAVException ) 5858590a0fdSAndre Fischer { 5868590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 5878590a0fdSAndre Fischer 5888590a0fdSAndre Fischer Init( rEnv ); 5898590a0fdSAndre Fischer 5908590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 5918590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 5928590a0fdSAndre Fischer inPath ); 5938590a0fdSAndre Fischer aReqProc.processPropFind( inDepth, 5948590a0fdSAndre Fischer inPropNames, 5958590a0fdSAndre Fischer ioResources, 5968590a0fdSAndre Fischer status ); 5978590a0fdSAndre Fischer 5988590a0fdSAndre Fischer if ( status == APR_SUCCESS && 5998590a0fdSAndre Fischer aReqProc.mpDAVException == 0 && 6008590a0fdSAndre Fischer ioResources.empty() ) 6018590a0fdSAndre Fischer { 6028590a0fdSAndre Fischer m_aEnv = DAVRequestEnvironment(); 6038590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_ERROR, inPath, (sal_uInt16)APR_EGENERAL ); 6048590a0fdSAndre Fischer } 6058590a0fdSAndre Fischer HandleError( aReqProc, 6068590a0fdSAndre Fischer inPath, rEnv ); 6078590a0fdSAndre Fischer } 6088590a0fdSAndre Fischer 6098590a0fdSAndre Fischer // ------------------------------------------------------------------- 6108590a0fdSAndre Fischer // PROPFIND - propnames 6118590a0fdSAndre Fischer // ------------------------------------------------------------------- 6128590a0fdSAndre Fischer void SerfSession::PROPFIND( const rtl::OUString & inPath, 6138590a0fdSAndre Fischer const Depth inDepth, 6148590a0fdSAndre Fischer std::vector< DAVResourceInfo > & ioResInfo, 6158590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 6168590a0fdSAndre Fischer throw( DAVException ) 6178590a0fdSAndre Fischer { 6188590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 6198590a0fdSAndre Fischer 6208590a0fdSAndre Fischer Init( rEnv ); 6218590a0fdSAndre Fischer 6228590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 6238590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 6248590a0fdSAndre Fischer inPath ); 6258590a0fdSAndre Fischer aReqProc.processPropFind( inDepth, 6268590a0fdSAndre Fischer ioResInfo, 6278590a0fdSAndre Fischer status ); 6288590a0fdSAndre Fischer 6298590a0fdSAndre Fischer if ( status == APR_SUCCESS && 6308590a0fdSAndre Fischer aReqProc.mpDAVException == 0 && 6318590a0fdSAndre Fischer ioResInfo.empty() ) 6328590a0fdSAndre Fischer { 6338590a0fdSAndre Fischer m_aEnv = DAVRequestEnvironment(); 6348590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_ERROR, inPath, (sal_uInt16)APR_EGENERAL ); 6358590a0fdSAndre Fischer } 6368590a0fdSAndre Fischer HandleError( aReqProc, 6378590a0fdSAndre Fischer inPath, rEnv ); 6388590a0fdSAndre Fischer } 6398590a0fdSAndre Fischer 6408590a0fdSAndre Fischer // ------------------------------------------------------------------- 6418590a0fdSAndre Fischer // PROPPATCH 6428590a0fdSAndre Fischer // ------------------------------------------------------------------- 6438590a0fdSAndre Fischer void SerfSession::PROPPATCH( const rtl::OUString & inPath, 6448590a0fdSAndre Fischer const std::vector< ProppatchValue > & inValues, 6458590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 6468590a0fdSAndre Fischer throw( DAVException ) 6478590a0fdSAndre Fischer { 6488590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 6498590a0fdSAndre Fischer 6508590a0fdSAndre Fischer Init( rEnv ); 6518590a0fdSAndre Fischer 6528590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 6538590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 6548590a0fdSAndre Fischer inPath ); 6558590a0fdSAndre Fischer aReqProc.processPropPatch( inValues, 6568590a0fdSAndre Fischer status ); 6578590a0fdSAndre Fischer 6588590a0fdSAndre Fischer HandleError( aReqProc, 6598590a0fdSAndre Fischer inPath, rEnv ); 6608590a0fdSAndre Fischer } 6618590a0fdSAndre Fischer 6628590a0fdSAndre Fischer // ------------------------------------------------------------------- 6638590a0fdSAndre Fischer // HEAD 6648590a0fdSAndre Fischer // ------------------------------------------------------------------- 6658590a0fdSAndre Fischer void SerfSession::HEAD( const ::rtl::OUString & inPath, 6668590a0fdSAndre Fischer const std::vector< ::rtl::OUString > & inHeaderNames, 6678590a0fdSAndre Fischer DAVResource & ioResource, 6688590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 6698590a0fdSAndre Fischer throw( DAVException ) 6708590a0fdSAndre Fischer { 6718590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 6728590a0fdSAndre Fischer 6738590a0fdSAndre Fischer Init( rEnv ); 6748590a0fdSAndre Fischer 6758590a0fdSAndre Fischer m_bIsHeadRequestInProgress = true; 6768590a0fdSAndre Fischer 6778590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 6788590a0fdSAndre Fischer inPath ); 6798590a0fdSAndre Fischer ioResource.uri = inPath; 6808590a0fdSAndre Fischer ioResource.properties.clear(); 6818590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 6828590a0fdSAndre Fischer aReqProc.processHead( inHeaderNames, 6838590a0fdSAndre Fischer ioResource, 6848590a0fdSAndre Fischer status ); 6858590a0fdSAndre Fischer 6868590a0fdSAndre Fischer HandleError( aReqProc, 6878590a0fdSAndre Fischer inPath, rEnv ); 6888590a0fdSAndre Fischer m_bIsHeadRequestInProgress = false; 6898590a0fdSAndre Fischer } 6908590a0fdSAndre Fischer 6918590a0fdSAndre Fischer // ------------------------------------------------------------------- 6928590a0fdSAndre Fischer // GET 6938590a0fdSAndre Fischer // ------------------------------------------------------------------- 6948590a0fdSAndre Fischer uno::Reference< io::XInputStream > 6958590a0fdSAndre Fischer SerfSession::GET( const rtl::OUString & inPath, 6968590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 6978590a0fdSAndre Fischer throw ( DAVException ) 6988590a0fdSAndre Fischer { 6998590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 7008590a0fdSAndre Fischer 7018590a0fdSAndre Fischer Init( rEnv ); 7028590a0fdSAndre Fischer 7038590a0fdSAndre Fischer uno::Reference< SerfInputStream > xInputStream( new SerfInputStream ); 7048590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 7058590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 7068590a0fdSAndre Fischer inPath ); 7078590a0fdSAndre Fischer aReqProc.processGet( xInputStream, 7088590a0fdSAndre Fischer status ); 7098590a0fdSAndre Fischer 7108590a0fdSAndre Fischer HandleError( aReqProc, 7118590a0fdSAndre Fischer inPath, rEnv ); 7128590a0fdSAndre Fischer 7138590a0fdSAndre Fischer return uno::Reference< io::XInputStream >( xInputStream.get() ); 7148590a0fdSAndre Fischer } 7158590a0fdSAndre Fischer 7168590a0fdSAndre Fischer // ------------------------------------------------------------------- 7178590a0fdSAndre Fischer // GET 7188590a0fdSAndre Fischer // ------------------------------------------------------------------- 7198590a0fdSAndre Fischer void SerfSession::GET( const rtl::OUString & inPath, 7208590a0fdSAndre Fischer uno::Reference< io::XOutputStream > & ioOutputStream, 7218590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 7228590a0fdSAndre Fischer throw ( DAVException ) 7238590a0fdSAndre Fischer { 7248590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 7258590a0fdSAndre Fischer 7268590a0fdSAndre Fischer Init( rEnv ); 7278590a0fdSAndre Fischer 7288590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 7298590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 7308590a0fdSAndre Fischer inPath ); 7318590a0fdSAndre Fischer aReqProc.processGet( ioOutputStream, 7328590a0fdSAndre Fischer status ); 7338590a0fdSAndre Fischer 7348590a0fdSAndre Fischer HandleError( aReqProc, 7358590a0fdSAndre Fischer inPath, rEnv ); 7368590a0fdSAndre Fischer } 7378590a0fdSAndre Fischer 7388590a0fdSAndre Fischer // ------------------------------------------------------------------- 7398590a0fdSAndre Fischer // GET 7408590a0fdSAndre Fischer // ------------------------------------------------------------------- 7418590a0fdSAndre Fischer uno::Reference< io::XInputStream > 7428590a0fdSAndre Fischer SerfSession::GET( const rtl::OUString & inPath, 7438590a0fdSAndre Fischer const std::vector< ::rtl::OUString > & inHeaderNames, 7448590a0fdSAndre Fischer DAVResource & ioResource, 7458590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 7468590a0fdSAndre Fischer throw ( DAVException ) 7478590a0fdSAndre Fischer { 7488590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 7498590a0fdSAndre Fischer 7508590a0fdSAndre Fischer Init( rEnv ); 7518590a0fdSAndre Fischer 7528590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 7538590a0fdSAndre Fischer inPath ); 7548590a0fdSAndre Fischer uno::Reference< SerfInputStream > xInputStream( new SerfInputStream ); 7558590a0fdSAndre Fischer ioResource.uri = inPath; 7568590a0fdSAndre Fischer ioResource.properties.clear(); 7578590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 7588590a0fdSAndre Fischer aReqProc.processGet( xInputStream, 7598590a0fdSAndre Fischer inHeaderNames, 7608590a0fdSAndre Fischer ioResource, 7618590a0fdSAndre Fischer status ); 7628590a0fdSAndre Fischer 7638590a0fdSAndre Fischer HandleError( aReqProc, 7648590a0fdSAndre Fischer inPath, rEnv ); 7658590a0fdSAndre Fischer 7668590a0fdSAndre Fischer return uno::Reference< io::XInputStream >( xInputStream.get() ); 7678590a0fdSAndre Fischer } 7688590a0fdSAndre Fischer 7698590a0fdSAndre Fischer 7708590a0fdSAndre Fischer // ------------------------------------------------------------------- 7718590a0fdSAndre Fischer // GET 7728590a0fdSAndre Fischer // ------------------------------------------------------------------- 7738590a0fdSAndre Fischer void SerfSession::GET( const rtl::OUString & inPath, 7748590a0fdSAndre Fischer uno::Reference< io::XOutputStream > & ioOutputStream, 7758590a0fdSAndre Fischer const std::vector< ::rtl::OUString > & inHeaderNames, 7768590a0fdSAndre Fischer DAVResource & ioResource, 7778590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 7788590a0fdSAndre Fischer throw ( DAVException ) 7798590a0fdSAndre Fischer { 7808590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 7818590a0fdSAndre Fischer 7828590a0fdSAndre Fischer Init( rEnv ); 7838590a0fdSAndre Fischer 7848590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 7858590a0fdSAndre Fischer inPath ); 7868590a0fdSAndre Fischer ioResource.uri = inPath; 7878590a0fdSAndre Fischer ioResource.properties.clear(); 7888590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 7898590a0fdSAndre Fischer aReqProc.processGet( ioOutputStream, 7908590a0fdSAndre Fischer inHeaderNames, 7918590a0fdSAndre Fischer ioResource, 7928590a0fdSAndre Fischer status ); 7938590a0fdSAndre Fischer 7948590a0fdSAndre Fischer HandleError( aReqProc, 7958590a0fdSAndre Fischer inPath, rEnv ); 7968590a0fdSAndre Fischer } 7978590a0fdSAndre Fischer 7988590a0fdSAndre Fischer // ------------------------------------------------------------------- 7998590a0fdSAndre Fischer // PUT 8008590a0fdSAndre Fischer // ------------------------------------------------------------------- 8018590a0fdSAndre Fischer void SerfSession::PUT( const rtl::OUString & inPath, 8028590a0fdSAndre Fischer const uno::Reference< io::XInputStream > & inInputStream, 8038590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 8048590a0fdSAndre Fischer throw ( DAVException ) 8058590a0fdSAndre Fischer { 8068590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 8078590a0fdSAndre Fischer 8088590a0fdSAndre Fischer Init( rEnv ); 8098590a0fdSAndre Fischer 8108590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 8118590a0fdSAndre Fischer inPath ); 8128590a0fdSAndre Fischer uno::Sequence< sal_Int8 > aDataToSend; 8138590a0fdSAndre Fischer if ( !getDataFromInputStream( inInputStream, aDataToSend, false ) ) 8148590a0fdSAndre Fischer throw DAVException( DAVException::DAV_INVALID_ARG ); 8158590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 8168590a0fdSAndre Fischer aReqProc.processPut( reinterpret_cast< const char * >( aDataToSend.getConstArray() ), 8178590a0fdSAndre Fischer aDataToSend.getLength(), 8188590a0fdSAndre Fischer status ); 8198590a0fdSAndre Fischer 8208590a0fdSAndre Fischer HandleError( aReqProc, 8218590a0fdSAndre Fischer inPath, rEnv ); 8228590a0fdSAndre Fischer } 8238590a0fdSAndre Fischer 8248590a0fdSAndre Fischer // ------------------------------------------------------------------- 8258590a0fdSAndre Fischer // POST 8268590a0fdSAndre Fischer // ------------------------------------------------------------------- 8278590a0fdSAndre Fischer uno::Reference< io::XInputStream > 8288590a0fdSAndre Fischer SerfSession::POST( const rtl::OUString & inPath, 8298590a0fdSAndre Fischer const rtl::OUString & rContentType, 8308590a0fdSAndre Fischer const rtl::OUString & rReferer, 8318590a0fdSAndre Fischer const uno::Reference< io::XInputStream > & inInputStream, 8328590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 8338590a0fdSAndre Fischer throw ( DAVException ) 8348590a0fdSAndre Fischer { 8358590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 8368590a0fdSAndre Fischer 8378590a0fdSAndre Fischer uno::Sequence< sal_Int8 > aDataToSend; 8388590a0fdSAndre Fischer if ( !getDataFromInputStream( inInputStream, aDataToSend, true ) ) 8398590a0fdSAndre Fischer { 8408590a0fdSAndre Fischer throw DAVException( DAVException::DAV_INVALID_ARG ); 8418590a0fdSAndre Fischer } 8428590a0fdSAndre Fischer 8438590a0fdSAndre Fischer Init( rEnv ); 8448590a0fdSAndre Fischer 8458590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 8468590a0fdSAndre Fischer inPath ); 8478590a0fdSAndre Fischer uno::Reference< SerfInputStream > xInputStream( new SerfInputStream ); 8488590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 8498590a0fdSAndre Fischer aReqProc.processPost( reinterpret_cast< const char * >( aDataToSend.getConstArray() ), 8508590a0fdSAndre Fischer aDataToSend.getLength(), 8518590a0fdSAndre Fischer rContentType, 8528590a0fdSAndre Fischer rReferer, 8538590a0fdSAndre Fischer xInputStream, 8548590a0fdSAndre Fischer status ); 8558590a0fdSAndre Fischer 8568590a0fdSAndre Fischer HandleError( aReqProc, 8578590a0fdSAndre Fischer inPath, rEnv ); 8588590a0fdSAndre Fischer return uno::Reference< io::XInputStream >( xInputStream.get() ); 8598590a0fdSAndre Fischer } 8608590a0fdSAndre Fischer 8618590a0fdSAndre Fischer // ------------------------------------------------------------------- 8628590a0fdSAndre Fischer // POST 8638590a0fdSAndre Fischer // ------------------------------------------------------------------- 8648590a0fdSAndre Fischer void SerfSession::POST( const rtl::OUString & inPath, 8658590a0fdSAndre Fischer const rtl::OUString & rContentType, 8668590a0fdSAndre Fischer const rtl::OUString & rReferer, 8678590a0fdSAndre Fischer const uno::Reference< io::XInputStream > & inInputStream, 8688590a0fdSAndre Fischer uno::Reference< io::XOutputStream > & oOutputStream, 8698590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 8708590a0fdSAndre Fischer throw ( DAVException ) 8718590a0fdSAndre Fischer { 8728590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 8738590a0fdSAndre Fischer 8748590a0fdSAndre Fischer uno::Sequence< sal_Int8 > aDataToSend; 8758590a0fdSAndre Fischer if ( !getDataFromInputStream( inInputStream, aDataToSend, true ) ) 8768590a0fdSAndre Fischer { 8778590a0fdSAndre Fischer throw DAVException( DAVException::DAV_INVALID_ARG ); 8788590a0fdSAndre Fischer } 8798590a0fdSAndre Fischer 8808590a0fdSAndre Fischer Init( rEnv ); 8818590a0fdSAndre Fischer 8828590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 8838590a0fdSAndre Fischer inPath ); 8848590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 8858590a0fdSAndre Fischer aReqProc.processPost( reinterpret_cast< const char * >( aDataToSend.getConstArray() ), 8868590a0fdSAndre Fischer aDataToSend.getLength(), 8878590a0fdSAndre Fischer rContentType, 8888590a0fdSAndre Fischer rReferer, 8898590a0fdSAndre Fischer oOutputStream, 8908590a0fdSAndre Fischer status ); 8918590a0fdSAndre Fischer 8928590a0fdSAndre Fischer HandleError( aReqProc, 8938590a0fdSAndre Fischer inPath, rEnv ); 8948590a0fdSAndre Fischer } 8958590a0fdSAndre Fischer 8968590a0fdSAndre Fischer // ------------------------------------------------------------------- 8978590a0fdSAndre Fischer // MKCOL 8988590a0fdSAndre Fischer // ------------------------------------------------------------------- 8998590a0fdSAndre Fischer void SerfSession::MKCOL( const rtl::OUString & inPath, 9008590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 9018590a0fdSAndre Fischer throw ( DAVException ) 9028590a0fdSAndre Fischer { 9038590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 9048590a0fdSAndre Fischer 9058590a0fdSAndre Fischer Init( rEnv ); 9068590a0fdSAndre Fischer 9078590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 9088590a0fdSAndre Fischer inPath ); 9098590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 9108590a0fdSAndre Fischer aReqProc.processMkCol( status ); 9118590a0fdSAndre Fischer 9128590a0fdSAndre Fischer HandleError( aReqProc, 9138590a0fdSAndre Fischer inPath, rEnv ); 9148590a0fdSAndre Fischer } 9158590a0fdSAndre Fischer 9168590a0fdSAndre Fischer // ------------------------------------------------------------------- 9178590a0fdSAndre Fischer // COPY 9188590a0fdSAndre Fischer // ------------------------------------------------------------------- 9198590a0fdSAndre Fischer void SerfSession::COPY( const rtl::OUString & inSourceURL, 9208590a0fdSAndre Fischer const rtl::OUString & inDestinationURL, 9218590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv, 9228590a0fdSAndre Fischer sal_Bool inOverWrite ) 9238590a0fdSAndre Fischer throw ( DAVException ) 9248590a0fdSAndre Fischer { 9258590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 9268590a0fdSAndre Fischer 9278590a0fdSAndre Fischer Init( rEnv ); 9288590a0fdSAndre Fischer 9298590a0fdSAndre Fischer SerfUri theSourceUri( inSourceURL ); 9308590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 9318590a0fdSAndre Fischer theSourceUri.GetPath() ); 9328590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 9338590a0fdSAndre Fischer aReqProc.processCopy( inDestinationURL, 9348590a0fdSAndre Fischer (inOverWrite ? true : false), 9358590a0fdSAndre Fischer status ); 9368590a0fdSAndre Fischer 9378590a0fdSAndre Fischer HandleError( aReqProc, 9388590a0fdSAndre Fischer inSourceURL, rEnv ); 9398590a0fdSAndre Fischer } 9408590a0fdSAndre Fischer 9418590a0fdSAndre Fischer // ------------------------------------------------------------------- 9428590a0fdSAndre Fischer // MOVE 9438590a0fdSAndre Fischer // ------------------------------------------------------------------- 9448590a0fdSAndre Fischer void SerfSession::MOVE( const rtl::OUString & inSourceURL, 9458590a0fdSAndre Fischer const rtl::OUString & inDestinationURL, 9468590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv, 9478590a0fdSAndre Fischer sal_Bool inOverWrite ) 9488590a0fdSAndre Fischer throw ( DAVException ) 9498590a0fdSAndre Fischer { 9508590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 9518590a0fdSAndre Fischer 9528590a0fdSAndre Fischer Init( rEnv ); 9538590a0fdSAndre Fischer 9548590a0fdSAndre Fischer SerfUri theSourceUri( inSourceURL ); 9558590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 9568590a0fdSAndre Fischer theSourceUri.GetPath() ); 9578590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 9588590a0fdSAndre Fischer aReqProc.processMove( inDestinationURL, 9598590a0fdSAndre Fischer (inOverWrite ? true : false), 9608590a0fdSAndre Fischer status ); 9618590a0fdSAndre Fischer 9628590a0fdSAndre Fischer HandleError( aReqProc, 9638590a0fdSAndre Fischer inSourceURL, rEnv ); 9648590a0fdSAndre Fischer } 9658590a0fdSAndre Fischer 9668590a0fdSAndre Fischer // ------------------------------------------------------------------- 9678590a0fdSAndre Fischer // DESTROY 9688590a0fdSAndre Fischer // ------------------------------------------------------------------- 9698590a0fdSAndre Fischer void SerfSession::DESTROY( const rtl::OUString & inPath, 9708590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 9718590a0fdSAndre Fischer throw ( DAVException ) 9728590a0fdSAndre Fischer { 9738590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 9748590a0fdSAndre Fischer 9758590a0fdSAndre Fischer Init( rEnv ); 9768590a0fdSAndre Fischer 9778590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 9788590a0fdSAndre Fischer inPath ); 9798590a0fdSAndre Fischer apr_status_t status = APR_SUCCESS; 9808590a0fdSAndre Fischer aReqProc.processDelete( status ); 9818590a0fdSAndre Fischer 9828590a0fdSAndre Fischer HandleError( aReqProc, 9838590a0fdSAndre Fischer inPath, rEnv ); 9848590a0fdSAndre Fischer } 9858590a0fdSAndre Fischer 9868590a0fdSAndre Fischer // ------------------------------------------------------------------- 9878590a0fdSAndre Fischer /* 9888590a0fdSAndre Fischer namespace 9898590a0fdSAndre Fischer { 9908590a0fdSAndre Fischer sal_Int32 lastChanceToSendRefreshRequest( TimeValue const & rStart, 9918590a0fdSAndre Fischer int timeout ) 9928590a0fdSAndre Fischer { 9938590a0fdSAndre Fischer TimeValue aEnd; 9948590a0fdSAndre Fischer osl_getSystemTime( &aEnd ); 9958590a0fdSAndre Fischer 9968590a0fdSAndre Fischer // Try to estimate a safe absolute time for sending the 9978590a0fdSAndre Fischer // lock refresh request. 9988590a0fdSAndre Fischer sal_Int32 lastChanceToSendRefreshRequest = -1; 9998590a0fdSAndre Fischer if ( timeout != NE_TIMEOUT_INFINITE ) 10008590a0fdSAndre Fischer { 10018590a0fdSAndre Fischer sal_Int32 calltime = aEnd.Seconds - rStart.Seconds; 10028590a0fdSAndre Fischer if ( calltime <= timeout ) 10038590a0fdSAndre Fischer { 10048590a0fdSAndre Fischer lastChanceToSendRefreshRequest 10058590a0fdSAndre Fischer = aEnd.Seconds + timeout - calltime; 10068590a0fdSAndre Fischer } 10078590a0fdSAndre Fischer else 10088590a0fdSAndre Fischer { 10098590a0fdSAndre Fischer OSL_TRACE( "No chance to refresh lock before timeout!" ); 10108590a0fdSAndre Fischer } 10118590a0fdSAndre Fischer } 10128590a0fdSAndre Fischer return lastChanceToSendRefreshRequest; 10138590a0fdSAndre Fischer } 10148590a0fdSAndre Fischer 10158590a0fdSAndre Fischer } // namespace 10168590a0fdSAndre Fischer */ 10178590a0fdSAndre Fischer // ------------------------------------------------------------------- 10188590a0fdSAndre Fischer // LOCK (set new lock) 10198590a0fdSAndre Fischer // ------------------------------------------------------------------- 10208590a0fdSAndre Fischer void SerfSession::LOCK( const ::rtl::OUString & inPath, 10218590a0fdSAndre Fischer ucb::Lock & /*rLock*/, 10228590a0fdSAndre Fischer const DAVRequestEnvironment & rEnv ) 10238590a0fdSAndre Fischer throw ( DAVException ) 10248590a0fdSAndre Fischer { 10258590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 10268590a0fdSAndre Fischer 10278590a0fdSAndre Fischer Init( rEnv ); 10288590a0fdSAndre Fischer 10298590a0fdSAndre Fischer SerfRequestProcessor aReqProc( *this, 10308590a0fdSAndre Fischer inPath ); 10318590a0fdSAndre Fischer HandleError( aReqProc, 10328590a0fdSAndre Fischer inPath, rEnv ); 10338590a0fdSAndre Fischer /* Create a depth zero, exclusive write lock, with default timeout 10348590a0fdSAndre Fischer * (allowing a server to pick a default). token, owner and uri are 10358590a0fdSAndre Fischer * unset. */ 10368590a0fdSAndre Fischer /* 10378590a0fdSAndre Fischer SerfLock * theLock = ne_lock_create(); 10388590a0fdSAndre Fischer 10398590a0fdSAndre Fischer // Set the lock uri 10408590a0fdSAndre Fischer ne_uri aUri; 10418590a0fdSAndre Fischer ne_uri_parse( rtl::OUStringToOString( makeAbsoluteURL( inPath ), 10428590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr(), 10438590a0fdSAndre Fischer &aUri ); 10448590a0fdSAndre Fischer theLock->uri = aUri; 10458590a0fdSAndre Fischer 10468590a0fdSAndre Fischer // Set the lock depth 10478590a0fdSAndre Fischer switch( rLock.Depth ) 10488590a0fdSAndre Fischer { 10498590a0fdSAndre Fischer case ucb::LockDepth_ZERO: 10508590a0fdSAndre Fischer theLock->depth = NE_DEPTH_ZERO; 10518590a0fdSAndre Fischer break; 10528590a0fdSAndre Fischer case ucb::LockDepth_ONE: 10538590a0fdSAndre Fischer theLock->depth = NE_DEPTH_ONE; 10548590a0fdSAndre Fischer break; 10558590a0fdSAndre Fischer case ucb::LockDepth_INFINITY: 10568590a0fdSAndre Fischer theLock->depth = NE_DEPTH_INFINITE; 10578590a0fdSAndre Fischer break; 10588590a0fdSAndre Fischer default: 10598590a0fdSAndre Fischer throw DAVException( DAVException::DAV_INVALID_ARG ); 10608590a0fdSAndre Fischer } 10618590a0fdSAndre Fischer 10628590a0fdSAndre Fischer // Set the lock scope 10638590a0fdSAndre Fischer switch ( rLock.Scope ) 10648590a0fdSAndre Fischer { 10658590a0fdSAndre Fischer case ucb::LockScope_EXCLUSIVE: 10668590a0fdSAndre Fischer theLock->scope = ne_lockscope_exclusive; 10678590a0fdSAndre Fischer break; 10688590a0fdSAndre Fischer case ucb::LockScope_SHARED: 10698590a0fdSAndre Fischer theLock->scope = ne_lockscope_shared; 10708590a0fdSAndre Fischer break; 10718590a0fdSAndre Fischer default: 10728590a0fdSAndre Fischer throw DAVException( DAVException::DAV_INVALID_ARG ); 10738590a0fdSAndre Fischer } 10748590a0fdSAndre Fischer 10758590a0fdSAndre Fischer // Set the lock timeout 10768590a0fdSAndre Fischer theLock->timeout = (long)rLock.Timeout; 10778590a0fdSAndre Fischer 10788590a0fdSAndre Fischer // Set the lock owner 10798590a0fdSAndre Fischer rtl::OUString aValue; 10808590a0fdSAndre Fischer rLock.Owner >>= aValue; 10818590a0fdSAndre Fischer theLock->owner = 10828590a0fdSAndre Fischer ne_strdup( rtl::OUStringToOString( aValue, 10838590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr() ); 10848590a0fdSAndre Fischer TimeValue startCall; 10858590a0fdSAndre Fischer osl_getSystemTime( &startCall ); 10868590a0fdSAndre Fischer 10878590a0fdSAndre Fischer int theRetVal = ne_lock( m_pHttpSession, theLock ); 10888590a0fdSAndre Fischer 10898590a0fdSAndre Fischer if ( theRetVal == NE_OK ) 10908590a0fdSAndre Fischer { 10918590a0fdSAndre Fischer m_aSerfLockStore.addLock( theLock, 10928590a0fdSAndre Fischer this, 10938590a0fdSAndre Fischer lastChanceToSendRefreshRequest( 10948590a0fdSAndre Fischer startCall, theLock->timeout ) ); 10958590a0fdSAndre Fischer 10968590a0fdSAndre Fischer uno::Sequence< rtl::OUString > aTokens( 1 ); 10978590a0fdSAndre Fischer aTokens[ 0 ] = rtl::OUString::createFromAscii( theLock->token ); 10988590a0fdSAndre Fischer rLock.LockTokens = aTokens; 10998590a0fdSAndre Fischer 11008590a0fdSAndre Fischer OSL_TRACE( "SerfSession::LOCK: created lock for %s. token: %s", 11018590a0fdSAndre Fischer rtl::OUStringToOString( makeAbsoluteURL( inPath ), 11028590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr(), 11038590a0fdSAndre Fischer theLock->token ); 11048590a0fdSAndre Fischer } 11058590a0fdSAndre Fischer else 11068590a0fdSAndre Fischer { 11078590a0fdSAndre Fischer ne_lock_destroy( theLock ); 11088590a0fdSAndre Fischer 11098590a0fdSAndre Fischer OSL_TRACE( "SerfSession::LOCK: obtaining lock for %s failed!", 11108590a0fdSAndre Fischer rtl::OUStringToOString( makeAbsoluteURL( inPath ), 11118590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr() ); 11128590a0fdSAndre Fischer } 11138590a0fdSAndre Fischer 11148590a0fdSAndre Fischer HandleError( theRetVal, inPath, rEnv ); 11158590a0fdSAndre Fischer */ 11168590a0fdSAndre Fischer } 11178590a0fdSAndre Fischer 11188590a0fdSAndre Fischer // ------------------------------------------------------------------- 11198590a0fdSAndre Fischer // LOCK (refresh existing lock) 11208590a0fdSAndre Fischer // ------------------------------------------------------------------- 11218590a0fdSAndre Fischer sal_Int64 SerfSession::LOCK( const ::rtl::OUString & /*inPath*/, 11228590a0fdSAndre Fischer sal_Int64 nTimeout, 11238590a0fdSAndre Fischer const DAVRequestEnvironment & /*rEnv*/ ) 11248590a0fdSAndre Fischer throw ( DAVException ) 11258590a0fdSAndre Fischer { 11268590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 11278590a0fdSAndre Fischer 11288590a0fdSAndre Fischer return nTimeout; 11298590a0fdSAndre Fischer /* 11308590a0fdSAndre Fischer // Try to get the neon lock from lock store 11318590a0fdSAndre Fischer SerfLock * theLock 11328590a0fdSAndre Fischer = m_aSerfLockStore.findByUri( makeAbsoluteURL( inPath ) ); 11338590a0fdSAndre Fischer if ( !theLock ) 11348590a0fdSAndre Fischer throw DAVException( DAVException::DAV_NOT_LOCKED ); 11358590a0fdSAndre Fischer 11368590a0fdSAndre Fischer Init( rEnv ); 11378590a0fdSAndre Fischer 11388590a0fdSAndre Fischer // refresh existing lock. 11398590a0fdSAndre Fischer theLock->timeout = static_cast< long >( nTimeout ); 11408590a0fdSAndre Fischer 11418590a0fdSAndre Fischer TimeValue startCall; 11428590a0fdSAndre Fischer osl_getSystemTime( &startCall ); 11438590a0fdSAndre Fischer 11448590a0fdSAndre Fischer int theRetVal = ne_lock_refresh( m_pHttpSession, theLock ); 11458590a0fdSAndre Fischer 11468590a0fdSAndre Fischer if ( theRetVal == NE_OK ) 11478590a0fdSAndre Fischer { 11488590a0fdSAndre Fischer m_aSerfLockStore.updateLock( theLock, 11498590a0fdSAndre Fischer lastChanceToSendRefreshRequest( 11508590a0fdSAndre Fischer startCall, theLock->timeout ) ); 11518590a0fdSAndre Fischer } 11528590a0fdSAndre Fischer 11538590a0fdSAndre Fischer HandleError( theRetVal, inPath, rEnv ); 11548590a0fdSAndre Fischer 11558590a0fdSAndre Fischer return theLock->timeout; 11568590a0fdSAndre Fischer */ 11578590a0fdSAndre Fischer } 11588590a0fdSAndre Fischer 11598590a0fdSAndre Fischer // ------------------------------------------------------------------- 11608590a0fdSAndre Fischer // LOCK (refresh existing lock) 11618590a0fdSAndre Fischer // ------------------------------------------------------------------- 11628590a0fdSAndre Fischer bool SerfSession::LOCK( SerfLock * /*pLock*/, 11638590a0fdSAndre Fischer sal_Int32 & /*rlastChanceToSendRefreshRequest*/ ) 11648590a0fdSAndre Fischer { 11658590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 11668590a0fdSAndre Fischer 11678590a0fdSAndre Fischer return true; 11688590a0fdSAndre Fischer /* 11698590a0fdSAndre Fischer // refresh existing lock. 11708590a0fdSAndre Fischer 11718590a0fdSAndre Fischer TimeValue startCall; 11728590a0fdSAndre Fischer osl_getSystemTime( &startCall ); 11738590a0fdSAndre Fischer 11748590a0fdSAndre Fischer if ( ne_lock_refresh( m_pHttpSession, pLock ) == NE_OK ) 11758590a0fdSAndre Fischer { 11768590a0fdSAndre Fischer rlastChanceToSendRefreshRequest 11778590a0fdSAndre Fischer = lastChanceToSendRefreshRequest( startCall, pLock->timeout ); 11788590a0fdSAndre Fischer 11798590a0fdSAndre Fischer OSL_TRACE( "Lock successfully refreshed." ); 11808590a0fdSAndre Fischer return true; 11818590a0fdSAndre Fischer } 11828590a0fdSAndre Fischer else 11838590a0fdSAndre Fischer { 11848590a0fdSAndre Fischer OSL_TRACE( "Lock not refreshed!" ); 11858590a0fdSAndre Fischer return false; 11868590a0fdSAndre Fischer } 11878590a0fdSAndre Fischer */ 11888590a0fdSAndre Fischer } 11898590a0fdSAndre Fischer 11908590a0fdSAndre Fischer // ------------------------------------------------------------------- 11918590a0fdSAndre Fischer // UNLOCK 11928590a0fdSAndre Fischer // ------------------------------------------------------------------- 11938590a0fdSAndre Fischer void SerfSession::UNLOCK( const ::rtl::OUString & /*inPath*/, 11948590a0fdSAndre Fischer const DAVRequestEnvironment & /*rEnv*/ ) 11958590a0fdSAndre Fischer throw ( DAVException ) 11968590a0fdSAndre Fischer { 11978590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 11988590a0fdSAndre Fischer 11998590a0fdSAndre Fischer /* 12008590a0fdSAndre Fischer // get the neon lock from lock store 12018590a0fdSAndre Fischer SerfLock * theLock 12028590a0fdSAndre Fischer = m_aSerfLockStore.findByUri( makeAbsoluteURL( inPath ) ); 12038590a0fdSAndre Fischer if ( !theLock ) 12048590a0fdSAndre Fischer throw DAVException( DAVException::DAV_NOT_LOCKED ); 12058590a0fdSAndre Fischer 12068590a0fdSAndre Fischer Init( rEnv ); 12078590a0fdSAndre Fischer 12088590a0fdSAndre Fischer int theRetVal = ne_unlock( m_pHttpSession, theLock ); 12098590a0fdSAndre Fischer 12108590a0fdSAndre Fischer if ( theRetVal == NE_OK ) 12118590a0fdSAndre Fischer { 12128590a0fdSAndre Fischer m_aSerfLockStore.removeLock( theLock ); 12138590a0fdSAndre Fischer ne_lock_destroy( theLock ); 12148590a0fdSAndre Fischer } 12158590a0fdSAndre Fischer else 12168590a0fdSAndre Fischer { 12178590a0fdSAndre Fischer OSL_TRACE( "SerfSession::UNLOCK: unlocking of %s failed.", 12188590a0fdSAndre Fischer rtl::OUStringToOString( makeAbsoluteURL( inPath ), 12198590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr() ); 12208590a0fdSAndre Fischer } 12218590a0fdSAndre Fischer 12228590a0fdSAndre Fischer HandleError( theRetVal, inPath, rEnv ); 12238590a0fdSAndre Fischer */ 12248590a0fdSAndre Fischer } 12258590a0fdSAndre Fischer 12268590a0fdSAndre Fischer // ------------------------------------------------------------------- 12278590a0fdSAndre Fischer // UNLOCK 12288590a0fdSAndre Fischer // ------------------------------------------------------------------- 12298590a0fdSAndre Fischer bool SerfSession::UNLOCK( SerfLock * /*pLock*/ ) 12308590a0fdSAndre Fischer { 12318590a0fdSAndre Fischer osl::Guard< osl::Mutex > theGuard( m_aMutex ); 12328590a0fdSAndre Fischer 12338590a0fdSAndre Fischer return true; 12348590a0fdSAndre Fischer /* 12358590a0fdSAndre Fischer if ( ne_unlock( m_pHttpSession, pLock ) == NE_OK ) 12368590a0fdSAndre Fischer { 12378590a0fdSAndre Fischer OSL_TRACE( "UNLOCK succeeded." ); 12388590a0fdSAndre Fischer return true; 12398590a0fdSAndre Fischer } 12408590a0fdSAndre Fischer else 12418590a0fdSAndre Fischer { 12428590a0fdSAndre Fischer OSL_TRACE( "UNLOCK failed!" ); 12438590a0fdSAndre Fischer return false; 12448590a0fdSAndre Fischer } 12458590a0fdSAndre Fischer */ 12468590a0fdSAndre Fischer } 12478590a0fdSAndre Fischer 12488590a0fdSAndre Fischer // ------------------------------------------------------------------- 12498590a0fdSAndre Fischer void SerfSession::abort() 12508590a0fdSAndre Fischer throw ( DAVException ) 12518590a0fdSAndre Fischer { 12528590a0fdSAndre Fischer // 11.11.09 (tkr): The following code lines causing crashes if 12538590a0fdSAndre Fischer // closing a ongoing connection. It turned out that this existing 12548590a0fdSAndre Fischer // solution doesn't work in multi-threading environments. 12558590a0fdSAndre Fischer // So I disabled them in 3.2. . Issue #73893# should fix it in OOo 3.3. 12568590a0fdSAndre Fischer //if ( m_pHttpSession ) 12578590a0fdSAndre Fischer // ne_close_connection( m_pHttpSession ); 12588590a0fdSAndre Fischer } 12598590a0fdSAndre Fischer 12608590a0fdSAndre Fischer // ------------------------------------------------------------------- 12618590a0fdSAndre Fischer const ucbhelper::InternetProxyServer & SerfSession::getProxySettings() const 12628590a0fdSAndre Fischer { 12638590a0fdSAndre Fischer if ( m_aUri.GetScheme().equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "http" ) ) || 12648590a0fdSAndre Fischer m_aUri.GetScheme().equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "https" ) ) ) 12658590a0fdSAndre Fischer { 12668590a0fdSAndre Fischer return m_rProxyDecider.getProxy( m_aUri.GetScheme(), 12678590a0fdSAndre Fischer m_aUri.GetHost(), 12688590a0fdSAndre Fischer m_aUri.GetPort() ); 12698590a0fdSAndre Fischer } 12708590a0fdSAndre Fischer else 12718590a0fdSAndre Fischer { 12728590a0fdSAndre Fischer // TODO: figure out, if this case can occur 12738590a0fdSAndre Fischer return m_rProxyDecider.getProxy( m_aUri.GetScheme(), 12748590a0fdSAndre Fischer rtl::OUString() /* not used */, 12758590a0fdSAndre Fischer -1 /* not used */ ); 12768590a0fdSAndre Fischer } 12778590a0fdSAndre Fischer } 12788590a0fdSAndre Fischer 12798590a0fdSAndre Fischer /* 12808590a0fdSAndre Fischer // ------------------------------------------------------------------- 12818590a0fdSAndre Fischer namespace { 12828590a0fdSAndre Fischer 12838590a0fdSAndre Fischer bool containsLocktoken( const uno::Sequence< ucb::Lock > & rLocks, 12848590a0fdSAndre Fischer const char * token ) 12858590a0fdSAndre Fischer { 12868590a0fdSAndre Fischer for ( sal_Int32 n = 0; n < rLocks.getLength(); ++n ) 12878590a0fdSAndre Fischer { 12888590a0fdSAndre Fischer const uno::Sequence< rtl::OUString > & rTokens 12898590a0fdSAndre Fischer = rLocks[ n ].LockTokens; 12908590a0fdSAndre Fischer for ( sal_Int32 m = 0; m < rTokens.getLength(); ++m ) 12918590a0fdSAndre Fischer { 12928590a0fdSAndre Fischer if ( rTokens[ m ].equalsAscii( token ) ) 12938590a0fdSAndre Fischer return true; 12948590a0fdSAndre Fischer } 12958590a0fdSAndre Fischer } 12968590a0fdSAndre Fischer return false; 12978590a0fdSAndre Fischer } 12988590a0fdSAndre Fischer 12998590a0fdSAndre Fischer } // namespace 13008590a0fdSAndre Fischer */ 13018590a0fdSAndre Fischer 13028590a0fdSAndre Fischer // ------------------------------------------------------------------- 13038590a0fdSAndre Fischer bool SerfSession::removeExpiredLocktoken( const rtl::OUString & /*inURL*/, 13048590a0fdSAndre Fischer const DAVRequestEnvironment & /*rEnv*/ ) 13058590a0fdSAndre Fischer { 13068590a0fdSAndre Fischer return true; 13078590a0fdSAndre Fischer /* 13088590a0fdSAndre Fischer SerfLock * theLock = m_aSerfLockStore.findByUri( inURL ); 13098590a0fdSAndre Fischer if ( !theLock ) 13108590a0fdSAndre Fischer return false; 13118590a0fdSAndre Fischer 13128590a0fdSAndre Fischer // do a lockdiscovery to check whether this lock is still valid. 13138590a0fdSAndre Fischer try 13148590a0fdSAndre Fischer { 13158590a0fdSAndre Fischer // @@@ Alternative: use ne_lock_discover() => less overhead 13168590a0fdSAndre Fischer 13178590a0fdSAndre Fischer std::vector< DAVResource > aResources; 13188590a0fdSAndre Fischer std::vector< rtl::OUString > aPropNames; 13198590a0fdSAndre Fischer aPropNames.push_back( DAVProperties::LOCKDISCOVERY ); 13208590a0fdSAndre Fischer 13218590a0fdSAndre Fischer PROPFIND( rEnv.m_aRequestURI, DAVZERO, aPropNames, aResources, rEnv ); 13228590a0fdSAndre Fischer 13238590a0fdSAndre Fischer if ( aResources.size() == 0 ) 13248590a0fdSAndre Fischer return false; 13258590a0fdSAndre Fischer 13268590a0fdSAndre Fischer std::vector< DAVPropertyValue >::const_iterator it 13278590a0fdSAndre Fischer = aResources[ 0 ].properties.begin(); 13288590a0fdSAndre Fischer std::vector< DAVPropertyValue >::const_iterator end 13298590a0fdSAndre Fischer = aResources[ 0 ].properties.end(); 13308590a0fdSAndre Fischer 13318590a0fdSAndre Fischer while ( it != end ) 13328590a0fdSAndre Fischer { 13338590a0fdSAndre Fischer if ( (*it).Name.equals( DAVProperties::LOCKDISCOVERY ) ) 13348590a0fdSAndre Fischer { 13358590a0fdSAndre Fischer uno::Sequence< ucb::Lock > aLocks; 13368590a0fdSAndre Fischer if ( !( (*it).Value >>= aLocks ) ) 13378590a0fdSAndre Fischer return false; 13388590a0fdSAndre Fischer 13398590a0fdSAndre Fischer if ( !containsLocktoken( aLocks, theLock->token ) ) 13408590a0fdSAndre Fischer { 13418590a0fdSAndre Fischer // expired! 13428590a0fdSAndre Fischer break; 13438590a0fdSAndre Fischer } 13448590a0fdSAndre Fischer 13458590a0fdSAndre Fischer // still valid. 13468590a0fdSAndre Fischer return false; 13478590a0fdSAndre Fischer } 13488590a0fdSAndre Fischer ++it; 13498590a0fdSAndre Fischer } 13508590a0fdSAndre Fischer 13518590a0fdSAndre Fischer // No lockdiscovery prop in propfind result / locktoken not found 13528590a0fdSAndre Fischer // in propfind result -> not locked 13538590a0fdSAndre Fischer OSL_TRACE( "SerfSession::removeExpiredLocktoken: Removing " 13548590a0fdSAndre Fischer " expired lock token for %s. token: %s", 13558590a0fdSAndre Fischer rtl::OUStringToOString( inURL, 13568590a0fdSAndre Fischer RTL_TEXTENCODING_UTF8 ).getStr(), 13578590a0fdSAndre Fischer theLock->token ); 13588590a0fdSAndre Fischer 13598590a0fdSAndre Fischer m_aSerfLockStore.removeLock( theLock ); 13608590a0fdSAndre Fischer ne_lock_destroy( theLock ); 13618590a0fdSAndre Fischer return true; 13628590a0fdSAndre Fischer } 13638590a0fdSAndre Fischer catch ( DAVException const & ) 13648590a0fdSAndre Fischer { 13658590a0fdSAndre Fischer } 13668590a0fdSAndre Fischer return false; 13678590a0fdSAndre Fischer */ 13688590a0fdSAndre Fischer } 13698590a0fdSAndre Fischer 13708590a0fdSAndre Fischer // ------------------------------------------------------------------- 13718590a0fdSAndre Fischer // HandleError 13728590a0fdSAndre Fischer // Common Error Handler 13738590a0fdSAndre Fischer // ------------------------------------------------------------------- 13748590a0fdSAndre Fischer void SerfSession::HandleError( SerfRequestProcessor& rReqProc, 13758590a0fdSAndre Fischer const rtl::OUString & /*inPath*/, 13768590a0fdSAndre Fischer const DAVRequestEnvironment & /*rEnv*/ ) 13778590a0fdSAndre Fischer throw ( DAVException ) 13788590a0fdSAndre Fischer { 13798590a0fdSAndre Fischer m_aEnv = DAVRequestEnvironment(); 13808590a0fdSAndre Fischer 13818590a0fdSAndre Fischer if ( rReqProc.mpDAVException ) 13828590a0fdSAndre Fischer { 13838590a0fdSAndre Fischer DAVException* mpDAVExp( rReqProc.mpDAVException ); 13848590a0fdSAndre Fischer 13858590a0fdSAndre Fischer serf_connection_reset( getSerfConnection() ); 13868590a0fdSAndre Fischer 13878590a0fdSAndre Fischer throw DAVException( mpDAVExp->getError(), 13888590a0fdSAndre Fischer mpDAVExp->getData(), 13898590a0fdSAndre Fischer mpDAVExp->getStatus() ); 13908590a0fdSAndre Fischer } 13918590a0fdSAndre Fischer 13928590a0fdSAndre Fischer /* 13938590a0fdSAndre Fischer // Map error code to DAVException. 13948590a0fdSAndre Fischer switch ( nError ) 13958590a0fdSAndre Fischer { 13968590a0fdSAndre Fischer case NE_OK: 13978590a0fdSAndre Fischer return; 13988590a0fdSAndre Fischer 13998590a0fdSAndre Fischer case NE_ERROR: // Generic error 14008590a0fdSAndre Fischer { 14018590a0fdSAndre Fischer rtl::OUString aText = rtl::OUString::createFromAscii( 14028590a0fdSAndre Fischer ne_get_error( m_pHttpSession ) ); 14038590a0fdSAndre Fischer 14048590a0fdSAndre Fischer sal_uInt16 code = makeStatusCode( aText ); 14058590a0fdSAndre Fischer 14068590a0fdSAndre Fischer if ( code == SC_LOCKED ) 14078590a0fdSAndre Fischer { 14088590a0fdSAndre Fischer if ( m_aSerfLockStore.findByUri( 14098590a0fdSAndre Fischer makeAbsoluteURL( inPath ) ) == 0 ) 14108590a0fdSAndre Fischer { 14118590a0fdSAndre Fischer // locked by 3rd party 14128590a0fdSAndre Fischer throw DAVException( DAVException::DAV_LOCKED ); 14138590a0fdSAndre Fischer } 14148590a0fdSAndre Fischer else 14158590a0fdSAndre Fischer { 14168590a0fdSAndre Fischer // locked by ourself 14178590a0fdSAndre Fischer throw DAVException( DAVException::DAV_LOCKED_SELF ); 14188590a0fdSAndre Fischer } 14198590a0fdSAndre Fischer } 14208590a0fdSAndre Fischer 14218590a0fdSAndre Fischer // Special handling for 400 and 412 status codes, which may indicate 14228590a0fdSAndre Fischer // that a lock previously obtained by us has been released meanwhile 14238590a0fdSAndre Fischer // by the server. Unfortunately, RFC is not clear at this point, 14248590a0fdSAndre Fischer // thus server implementations behave different... 14258590a0fdSAndre Fischer else if ( code == SC_BAD_REQUEST || code == SC_PRECONDITION_FAILED ) 14268590a0fdSAndre Fischer { 14278590a0fdSAndre Fischer if ( removeExpiredLocktoken( makeAbsoluteURL( inPath ), rEnv ) ) 14288590a0fdSAndre Fischer throw DAVException( DAVException::DAV_LOCK_EXPIRED ); 14298590a0fdSAndre Fischer } 14308590a0fdSAndre Fischer 14318590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_ERROR, aText, code ); 14328590a0fdSAndre Fischer } 14338590a0fdSAndre Fischer case NE_LOOKUP: // Name lookup failed. 14348590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_LOOKUP, 14358590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14368590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14378590a0fdSAndre Fischer 14388590a0fdSAndre Fischer case NE_AUTH: // User authentication failed on server 14398590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_AUTH, 14408590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14418590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14428590a0fdSAndre Fischer 14438590a0fdSAndre Fischer case NE_PROXYAUTH: // User authentication failed on proxy 14448590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_AUTHPROXY, 14458590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14468590a0fdSAndre Fischer m_aProxyName, m_nProxyPort ) ); 14478590a0fdSAndre Fischer 14488590a0fdSAndre Fischer case NE_CONNECT: // Could not connect to server 14498590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_CONNECT, 14508590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14518590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14528590a0fdSAndre Fischer 14538590a0fdSAndre Fischer case NE_TIMEOUT: // Connection timed out 14548590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_TIMEOUT, 14558590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14568590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14578590a0fdSAndre Fischer 14588590a0fdSAndre Fischer case NE_FAILED: // The precondition failed 14598590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_FAILED, 14608590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14618590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14628590a0fdSAndre Fischer 14638590a0fdSAndre Fischer case NE_RETRY: // Retry request (ne_end_request ONLY) 14648590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_RETRY, 14658590a0fdSAndre Fischer SerfUri::makeConnectionEndPointString( 14668590a0fdSAndre Fischer m_aHostName, m_nPort ) ); 14678590a0fdSAndre Fischer 14688590a0fdSAndre Fischer case NE_REDIRECT: 14698590a0fdSAndre Fischer { 14708590a0fdSAndre Fischer SerfUri aUri( ne_redirect_location( m_pHttpSession ) ); 14718590a0fdSAndre Fischer throw DAVException( 14728590a0fdSAndre Fischer DAVException::DAV_HTTP_REDIRECT, aUri.GetURI() ); 14738590a0fdSAndre Fischer } 14748590a0fdSAndre Fischer default: 14758590a0fdSAndre Fischer { 14768590a0fdSAndre Fischer OSL_TRACE( "SerfSession::HandleError : Unknown Serf error code!" ); 14778590a0fdSAndre Fischer throw DAVException( DAVException::DAV_HTTP_ERROR, 14788590a0fdSAndre Fischer rtl::OUString::createFromAscii( 14798590a0fdSAndre Fischer ne_get_error( m_pHttpSession ) ) ); 14808590a0fdSAndre Fischer } 14818590a0fdSAndre Fischer } 14828590a0fdSAndre Fischer */ 14838590a0fdSAndre Fischer } 14848590a0fdSAndre Fischer 14858590a0fdSAndre Fischer // ------------------------------------------------------------------- 14868590a0fdSAndre Fischer // static 14878590a0fdSAndre Fischer bool 14888590a0fdSAndre Fischer SerfSession::getDataFromInputStream( 14898590a0fdSAndre Fischer const uno::Reference< io::XInputStream > & xStream, 14908590a0fdSAndre Fischer uno::Sequence< sal_Int8 > & rData, 14918590a0fdSAndre Fischer bool bAppendTrailingZeroByte ) 14928590a0fdSAndre Fischer { 14938590a0fdSAndre Fischer if ( xStream.is() ) 14948590a0fdSAndre Fischer { 14958590a0fdSAndre Fischer uno::Reference< io::XSeekable > xSeekable( xStream, uno::UNO_QUERY ); 14968590a0fdSAndre Fischer if ( xSeekable.is() ) 14978590a0fdSAndre Fischer { 14988590a0fdSAndre Fischer try 14998590a0fdSAndre Fischer { 15008590a0fdSAndre Fischer sal_Int32 nSize 15018590a0fdSAndre Fischer = sal::static_int_cast<sal_Int32>(xSeekable->getLength()); 15028590a0fdSAndre Fischer sal_Int32 nRead 15038590a0fdSAndre Fischer = xStream->readBytes( rData, nSize ); 15048590a0fdSAndre Fischer 15058590a0fdSAndre Fischer if ( nRead == nSize ) 15068590a0fdSAndre Fischer { 15078590a0fdSAndre Fischer if ( bAppendTrailingZeroByte ) 15088590a0fdSAndre Fischer { 15098590a0fdSAndre Fischer rData.realloc( nSize + 1 ); 15108590a0fdSAndre Fischer rData[ nSize ] = sal_Int8( 0 ); 15118590a0fdSAndre Fischer } 15128590a0fdSAndre Fischer return true; 15138590a0fdSAndre Fischer } 15148590a0fdSAndre Fischer } 15158590a0fdSAndre Fischer catch ( io::NotConnectedException const & ) 15168590a0fdSAndre Fischer { 15178590a0fdSAndre Fischer // readBytes 15188590a0fdSAndre Fischer } 15198590a0fdSAndre Fischer catch ( io::BufferSizeExceededException const & ) 15208590a0fdSAndre Fischer { 15218590a0fdSAndre Fischer // readBytes 15228590a0fdSAndre Fischer } 15238590a0fdSAndre Fischer catch ( io::IOException const & ) 15248590a0fdSAndre Fischer { 15258590a0fdSAndre Fischer // getLength, readBytes 15268590a0fdSAndre Fischer } 15278590a0fdSAndre Fischer } 15288590a0fdSAndre Fischer else 15298590a0fdSAndre Fischer { 15308590a0fdSAndre Fischer try 15318590a0fdSAndre Fischer { 15328590a0fdSAndre Fischer uno::Sequence< sal_Int8 > aBuffer; 15338590a0fdSAndre Fischer sal_Int32 nPos = 0; 15348590a0fdSAndre Fischer 15358590a0fdSAndre Fischer sal_Int32 nRead = xStream->readSomeBytes( aBuffer, 65536 ); 15368590a0fdSAndre Fischer while ( nRead > 0 ) 15378590a0fdSAndre Fischer { 15388590a0fdSAndre Fischer if ( rData.getLength() < ( nPos + nRead ) ) 15398590a0fdSAndre Fischer rData.realloc( nPos + nRead ); 15408590a0fdSAndre Fischer 15418590a0fdSAndre Fischer aBuffer.realloc( nRead ); 15428590a0fdSAndre Fischer rtl_copyMemory( (void*)( rData.getArray() + nPos ), 15438590a0fdSAndre Fischer (const void*)aBuffer.getConstArray(), 15448590a0fdSAndre Fischer nRead ); 15458590a0fdSAndre Fischer nPos += nRead; 15468590a0fdSAndre Fischer 15478590a0fdSAndre Fischer aBuffer.realloc( 0 ); 15488590a0fdSAndre Fischer nRead = xStream->readSomeBytes( aBuffer, 65536 ); 15498590a0fdSAndre Fischer } 15508590a0fdSAndre Fischer 15518590a0fdSAndre Fischer if ( bAppendTrailingZeroByte ) 15528590a0fdSAndre Fischer { 15538590a0fdSAndre Fischer rData.realloc( nPos + 1 ); 15548590a0fdSAndre Fischer rData[ nPos ] = sal_Int8( 0 ); 15558590a0fdSAndre Fischer } 15568590a0fdSAndre Fischer return true; 15578590a0fdSAndre Fischer } 15588590a0fdSAndre Fischer catch ( io::NotConnectedException const & ) 15598590a0fdSAndre Fischer { 15608590a0fdSAndre Fischer // readBytes 15618590a0fdSAndre Fischer } 15628590a0fdSAndre Fischer catch ( io::BufferSizeExceededException const & ) 15638590a0fdSAndre Fischer { 15648590a0fdSAndre Fischer // readBytes 15658590a0fdSAndre Fischer } 15668590a0fdSAndre Fischer catch ( io::IOException const & ) 15678590a0fdSAndre Fischer { 15688590a0fdSAndre Fischer // readBytes 15698590a0fdSAndre Fischer } 15708590a0fdSAndre Fischer } 15718590a0fdSAndre Fischer } 15728590a0fdSAndre Fischer return false; 15738590a0fdSAndre Fischer } 15748590a0fdSAndre Fischer 15758590a0fdSAndre Fischer // --------------------------------------------------------------------- 15768590a0fdSAndre Fischer sal_Bool 15778590a0fdSAndre Fischer SerfSession::isDomainMatch( rtl::OUString certHostName ) 15788590a0fdSAndre Fischer { 15798590a0fdSAndre Fischer rtl::OUString hostName = getHostName(); 15808590a0fdSAndre Fischer 15818590a0fdSAndre Fischer if (hostName.equalsIgnoreAsciiCase( certHostName ) ) 15828590a0fdSAndre Fischer return sal_True; 15838590a0fdSAndre Fischer 15848590a0fdSAndre Fischer if ( 0 == certHostName.indexOf( rtl::OUString::createFromAscii( "*" ) ) && 15858590a0fdSAndre Fischer hostName.getLength() >= certHostName.getLength() ) 15868590a0fdSAndre Fischer { 15878590a0fdSAndre Fischer rtl::OUString cmpStr = certHostName.copy( 1 ); 15888590a0fdSAndre Fischer 15898590a0fdSAndre Fischer if ( hostName.matchIgnoreAsciiCase( 15908590a0fdSAndre Fischer cmpStr, hostName.getLength() - cmpStr.getLength() ) ) 15918590a0fdSAndre Fischer return sal_True; 15928590a0fdSAndre Fischer } 15938590a0fdSAndre Fischer return sal_False; 15948590a0fdSAndre Fischer } 15958590a0fdSAndre Fischer 15968590a0fdSAndre Fischer /* 15978590a0fdSAndre Fischer // --------------------------------------------------------------------- 15988590a0fdSAndre Fischer rtl::OUString SerfSession::makeAbsoluteURL( rtl::OUString const & rURL ) const 15998590a0fdSAndre Fischer { 16008590a0fdSAndre Fischer try 16018590a0fdSAndre Fischer { 16028590a0fdSAndre Fischer // Is URL relative or already absolute? 16038590a0fdSAndre Fischer if ( rURL[ 0 ] != sal_Unicode( '/' ) ) 16048590a0fdSAndre Fischer { 16058590a0fdSAndre Fischer // absolute. 16068590a0fdSAndre Fischer return rtl::OUString( rURL ); 16078590a0fdSAndre Fischer } 16088590a0fdSAndre Fischer else 16098590a0fdSAndre Fischer { 16108590a0fdSAndre Fischer ne_uri aUri; 16118590a0fdSAndre Fischer memset( &aUri, 0, sizeof( aUri ) ); 16128590a0fdSAndre Fischer 16138590a0fdSAndre Fischer ne_fill_server_uri( m_pHttpSession, &aUri ); 16148590a0fdSAndre Fischer aUri.path 16158590a0fdSAndre Fischer = ne_strdup( rtl::OUStringToOString( 16168590a0fdSAndre Fischer rURL, RTL_TEXTENCODING_UTF8 ).getStr() ); 16178590a0fdSAndre Fischer SerfUri aSerfUri( &aUri ); 16188590a0fdSAndre Fischer ne_uri_free( &aUri ); 16198590a0fdSAndre Fischer return aSerfUri.GetURI(); 16208590a0fdSAndre Fischer } 16218590a0fdSAndre Fischer } 16228590a0fdSAndre Fischer catch ( DAVException const & ) 16238590a0fdSAndre Fischer { 16248590a0fdSAndre Fischer } 16258590a0fdSAndre Fischer // error. 16268590a0fdSAndre Fischer return rtl::OUString(); 16278590a0fdSAndre Fischer } 16288590a0fdSAndre Fischer */ 1629