io/source/connector/ctr_socket.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "connector.hxx"
  22 #include <rtl/ustrbuf.hxx>
  23 #include <algorithm>
  24
  25 using namespace ::osl;
  26 using namespace ::rtl;
  27 using namespace ::com::sun::star::uno;
  28 using namespace ::com::sun::star::io;
  29 using namespace ::com::sun::star::connection;
  30
  31
  32 namespace stoc_connector {
  33     template<class T>
  34     void notifyListeners(SocketConnection * pCon, sal_Bool * notified, T t)
  35     {
  36           XStreamListener_hash_set listeners;
  37
  38         {
  39             ::osl::MutexGuard guard(pCon->_mutex);
  40             if(!*notified)
  41             {
  42                 *notified = sal_True;
  43                 listeners = pCon->_listeners;
  44             }
  45         }
  46
  47         ::std::for_each(listeners.begin(), listeners.end(), t);
  48     }
  49
  50
  51     static void callStarted(Reference<XStreamListener> xStreamListener)
  52     {
  53         xStreamListener->started();
  54     }
  55
  56     struct callError {
  57         const Any & any;
  58
  59         callError(const Any & any);
  60
  61         void operator () (Reference<XStreamListener> xStreamListener);
  62     };
  63
  64     callError::callError(const Any & aAny)
  65         : any(aAny)
  66     {
  67     }
  68
  69     void callError::operator () (Reference<XStreamListener> xStreamListener)
  70     {
  71         xStreamListener->error(any);
  72     }
  73
  74     static void callClosed(Reference<XStreamListener> xStreamListener)
  75     {
  76         xStreamListener->closed();
  77     }
  78
  79
  80     SocketConnection::SocketConnection( const OUString &sConnectionDescription ) :
  81         m_nStatus( 0 ),
  82         m_sDescription( sConnectionDescription ),
  83         _started(sal_False),
  84         _closed(sal_False),
  85         _error(sal_False)
  86     {
  87         // make it unique
  88         m_sDescription += ",uniqueValue=";
  89         m_sDescription += OUString::valueOf(
  90             sal::static_int_cast< sal_Int64 >(
  91                 reinterpret_cast< sal_IntPtr >(&m_socket)),
  92             10 );
  93     }
  94
  95     SocketConnection::~SocketConnection()
  96     {
  97     }
  98
  99     void SocketConnection::completeConnectionString()
 100     {
 101         sal_Int32 nPort;
 102
 103         nPort = m_socket.getPeerPort();
 104
 105         OUStringBuffer buf( 256 );
 106         buf.appendAscii( ",peerPort=" );
 107         buf.append( (sal_Int32) nPort );
 108         buf.appendAscii( ",peerHost=" );
 109         buf.append( m_socket.getPeerHost() );
 110
 111         buf.appendAscii( ",localPort=" );
 112         buf.append( (sal_Int32) nPort );
 113         buf.appendAscii( ",localHost=" );
 114         buf.append( m_socket.getLocalHost( ) );
 115
 116         m_sDescription += buf.makeStringAndClear();
 117     }
 118
 119     sal_Int32 SocketConnection::read( Sequence < sal_Int8 > & aReadBytes , sal_Int32 nBytesToRead )
 120             throw(::com::sun::star::io::IOException,
 121                   ::com::sun::star::uno::RuntimeException)
 122     {
 123         if( ! m_nStatus )
 124         {
 125             notifyListeners(this, &_started, callStarted);
 126
 127             if( aReadBytes.getLength() != nBytesToRead )
 128             {
 129                 aReadBytes.realloc( nBytesToRead );
 130             }
 131             sal_Int32 i = m_socket.read( aReadBytes.getArray()  , aReadBytes.getLength() );
 132
 133             if(i != nBytesToRead && m_socket.getError() != osl_Socket_E_None)
 134             {
 135                 OUString message("ctr_socket.cxx:SocketConnection::read: error - ");
 136                 message += m_socket.getErrorAsString();
 137
 138                 IOException ioException(message, Reference<XInterface>(static_cast<XConnection *>(this)));
 139
 140                 Any any;
 141                 any <<= ioException;
 142
 143                 notifyListeners(this, &_error, callError(any));
 144
 145                 throw ioException;
 146             }
 147
 148             return i;
 149         }
 150         else
 151         {
 152             OUString message("ctr_socket.cxx:SocketConnection::read: error - connection already closed");
 153
 154             IOException ioException(message, Reference<XInterface>(static_cast<XConnection *>(this)));
 155
 156             Any any;
 157             any <<= ioException;
 158
 159             notifyListeners(this, &_error, callError(any));
 160
 161             throw ioException;
 162         }
 163     }
 164
 165     void SocketConnection::write( const Sequence < sal_Int8 > &seq )
 166             throw(::com::sun::star::io::IOException,
 167                   ::com::sun::star::uno::RuntimeException)
 168     {
 169         if( ! m_nStatus )
 170         {
 171             if( m_socket.write( seq.getConstArray() , seq.getLength() ) != seq.getLength() )
 172             {
 173                 OUString message("ctr_socket.cxx:SocketConnection::write: error - ");
 174                 message += m_socket.getErrorAsString();
 175
 176                 IOException ioException(message, Reference<XInterface>(static_cast<XConnection *>(this)));
 177
 178                 Any any;
 179                 any <<= ioException;
 180
 181                 notifyListeners(this, &_error, callError(any));
 182
 183                 throw ioException;
 184             }
 185         }
 186         else
 187         {
 188             OUString message("ctr_socket.cxx:SocketConnection::write: error - connection already closed");
 189
 190             IOException ioException(message, Reference<XInterface>(static_cast<XConnection *>(this)));
 191
 192             Any any;
 193             any <<= ioException;
 194
 195             notifyListeners(this, &_error, callError(any));
 196
 197             throw ioException;
 198         }
 199     }
 200
 201     void SocketConnection::flush( )
 202             throw(::com::sun::star::io::IOException,
 203                   ::com::sun::star::uno::RuntimeException)
 204     {
 205
 206     }
 207
 208     void SocketConnection::close()
 209             throw(::com::sun::star::io::IOException,
 210                   ::com::sun::star::uno::RuntimeException)
 211     {
 212             // ensure that close is called only once
 213         if( 1 == osl_atomic_increment( (&m_nStatus) ) )
 214         {
 215             m_socket.shutdown();
 216             notifyListeners(this, &_closed, callClosed);
 217         }
 218     }
 219
 220     OUString SocketConnection::getDescription()
 221             throw( ::com::sun::star::uno::RuntimeException)
 222     {
 223         return m_sDescription;
 224     }
 225
 226
 227
 228     // XConnectionBroadcaster
 229     void SAL_CALL SocketConnection::addStreamListener(const Reference<XStreamListener> & aListener) throw(RuntimeException)
 230     {
 231         MutexGuard guard(_mutex);
 232
 233         _listeners.insert(aListener);
 234     }
 235
 236     void SAL_CALL SocketConnection::removeStreamListener(const Reference<XStreamListener> & aListener) throw(RuntimeException)
 237     {
 238         MutexGuard guard(_mutex);
 239
 240         _listeners.erase(aListener);
 241     }
 242 }
 243
 244 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */