extensions/source/plugin/unx/mediator.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: mediator.cxx,v $
  10  * $Revision: 1.11.90.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include <errno.h>
  34 #include <unistd.h>
  35
  36 #include <plugin/unx/mediator.hxx>
  37 #include <vcl/svapp.hxx>
  38
  39 #define MEDIATOR_MAGIC 0xf7a8d2f4
  40
  41 Mediator::Mediator( int nSocket ) :
  42         m_nSocket( nSocket ),
  43         m_pListener( NULL ),
  44         m_nCurrentID( 1 ),
  45         m_bValid( true )
  46 {
  47     m_pListener = new MediatorListener( this );
  48     m_pListener->create();
  49 }
  50
  51 Mediator::~Mediator()
  52 {
  53     if( m_pListener )
  54     {
  55         {
  56             ::vos::OGuard aGuard( m_pListener->m_aMutex );
  57             m_pListener->m_pMediator = NULL;
  58         }
  59         m_pListener = NULL;
  60         if( m_bValid )
  61         {
  62             ULONG aHeader[3];
  63             aHeader[0] = 0;
  64             aHeader[1] = 0;
  65             aHeader[2] = MEDIATOR_MAGIC;
  66             write( m_nSocket, aHeader, sizeof( aHeader ) );
  67         }
  68         // kick the thread out of its run method; it deletes itself
  69         close( m_nSocket );
  70     }
  71     else
  72         close( m_nSocket );
  73     for( std::vector< MediatorMessage* >::iterator it = m_aMessageQueue.begin();
  74          it != m_aMessageQueue.end(); ++it )
  75     {
  76         delete *it;
  77     }
  78 }
  79
  80
  81 ULONG Mediator::SendMessage( ULONG nBytes, const char* pBytes, ULONG nMessageID )
  82 {
  83     if( ! m_pListener )
  84         return 0;
  85
  86     NAMESPACE_VOS(OGuard) aGuard( m_aSendMutex );
  87     if( ! nMessageID )
  88         nMessageID = m_nCurrentID;
  89
  90     m_nCurrentID++;
  91     if( m_nCurrentID >= 1 << 24 ) // protection against overflow
  92         m_nCurrentID = 1;
  93
  94     if( ! m_bValid )
  95         return nMessageID;
  96
  97     ULONG* pBuffer = new ULONG[ (nBytes/sizeof(ULONG)) + 4 ];
  98     pBuffer[ 0 ] = nMessageID;
  99     pBuffer[ 1 ] = nBytes;
 100     pBuffer[ 2 ] = MEDIATOR_MAGIC;
 101     memcpy( &pBuffer[3], pBytes, (size_t)nBytes );
 102     write( m_nSocket, pBuffer, nBytes + 3*sizeof( ULONG ) );
 103     delete [] pBuffer;
 104
 105     return nMessageID;
 106 }
 107
 108 BOOL Mediator::WaitForMessage( ULONG nTimeOut )
 109 {
 110     if( ! m_pListener )
 111         return FALSE;
 112
 113     size_t nItems = m_aMessageQueue.size();
 114
 115     if( ! nTimeOut && nItems > 0 )
 116         return TRUE;
 117
 118     TimeValue aValue;
 119     aValue.Seconds = nTimeOut/1000;
 120     aValue.Nanosec = ( nTimeOut % 1000 ) * 1000;
 121
 122     while( m_aMessageQueue.size() == nItems )
 123     {
 124         m_aNewMessageCdtn.wait( & aValue );
 125         m_aNewMessageCdtn.reset();
 126         if( nTimeOut && m_aMessageQueue.size() == nItems )
 127             return FALSE;
 128     }
 129     return TRUE;
 130 }
 131
 132 MediatorMessage* Mediator::WaitForAnswer( ULONG nMessageID )
 133 {
 134     nMessageID &= 0x00ffffff;
 135     while( m_pListener )
 136     {
 137         {
 138             NAMESPACE_VOS(OGuard) aGuard( m_aQueueMutex );
 139             for( size_t i = 0; i < m_aMessageQueue.size(); i++ )
 140             {
 141                 MediatorMessage* pMessage = m_aMessageQueue[ i ];
 142                 ULONG nID = pMessage->m_nID;
 143                 if(  ( nID & 0xff000000 ) &&
 144                      ( ( nID & 0x00ffffff ) == nMessageID ) )
 145                 {
 146                     m_aMessageQueue.erase( m_aMessageQueue.begin() + i );
 147                     return pMessage;
 148                 }
 149             }
 150         }
 151         WaitForMessage( 10 );
 152     }
 153     return NULL;
 154 }
 155
 156 MediatorMessage* Mediator::GetNextMessage( BOOL bWait )
 157 {
 158     while( m_pListener )
 159     {
 160         {
 161             // guard must be after WaitForMessage, else the listener
 162             // cannot insert a new one -> deadlock
 163             NAMESPACE_VOS(OGuard) aGuard( m_aQueueMutex );
 164             for( size_t i = 0; i < m_aMessageQueue.size(); i++ )
 165             {
 166                 MediatorMessage* pMessage = m_aMessageQueue[ i ];
 167                 if( ! ( pMessage->m_nID & 0xff000000 ) )
 168                 {
 169                     m_aMessageQueue.erase( m_aMessageQueue.begin() + i );
 170                     return pMessage;
 171                 }
 172             }
 173             if( ! bWait )
 174                 return NULL;
 175         }
 176         WaitForMessage();
 177     }
 178     return NULL;
 179 }
 180
 181 MediatorMessage* Mediator::TransactMessage( ULONG nBytes, char* pBytes )
 182 {
 183     ULONG nID = SendMessage( nBytes, pBytes );
 184     return WaitForAnswer( nID );
 185 }
 186
 187 MediatorListener::MediatorListener( Mediator* pMediator ) :
 188         m_pMediator( pMediator )
 189 {
 190 }
 191
 192 MediatorListener::~MediatorListener()
 193 {
 194 }
 195
 196 void MediatorListener::run()
 197 {
 198     bool bRun = true;
 199     while( schedule() && m_pMediator && bRun )
 200     {
 201         ULONG nHeader[ 3 ];
 202         int nBytes;
 203
 204         if( m_pMediator && ( nBytes = read( m_pMediator->m_nSocket, nHeader, sizeof( nHeader ) ) ) == sizeof( nHeader ) && nHeader[2] == MEDIATOR_MAGIC)
 205         {
 206             if( nHeader[ 0 ] == 0 && nHeader[ 1 ] == 0 )
 207                 return;
 208             char* pBuffer = new char[ nHeader[ 1 ] ];
 209             if( m_pMediator && (ULONG)read( m_pMediator->m_nSocket, pBuffer, nHeader[ 1 ] ) == nHeader[ 1 ] )
 210             {
 211                 ::vos::OGuard aMyGuard( m_aMutex );
 212                 {
 213                     NAMESPACE_VOS(OGuard)
 214                         aGuard( m_pMediator->m_aQueueMutex );
 215                     MediatorMessage* pMessage =
 216                         new MediatorMessage( nHeader[ 0 ], nHeader[ 1 ], pBuffer );
 217                     m_pMediator->m_aMessageQueue.push_back( pMessage );
 218                 }
 219                 m_pMediator->m_aNewMessageCdtn.set();
 220                 m_pMediator->m_aNewMessageHdl.Call( m_pMediator );
 221             }
 222             else
 223             {
 224                 medDebug( 1, "got incomplete MediatorMessage: { %d, %d, %*s }\n",
 225                           nHeader[0], nHeader[1], nHeader[1], pBuffer );
 226                 bRun = false;
 227             }
 228             delete [] pBuffer;
 229         }
 230         else
 231         {
 232             medDebug( 1, "got incomplete message header of %d bytes ( nHeader = [ %u, %u ] ), errno is %d\n",
 233                       nBytes, nHeader[ 0 ], nHeader[ 1 ], (int)errno );
 234             bRun = false;
 235         }
 236     }
 237 }
 238
 239 void MediatorListener::onTerminated()
 240 {
 241     if( m_pMediator )
 242     {
 243         m_pMediator->m_aConnectionLostHdl.Call( m_pMediator );
 244         m_pMediator->m_pListener = NULL;
 245     }
 246     delete this;
 247 }
 248
 249 ULONG MediatorMessage::ExtractULONG()
 250 {
 251     if( ! m_pRun )
 252         m_pRun = m_pBytes;
 253
 254     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::ExtractULONG\n" );
 255     ULONG nCount;
 256     memcpy( &nCount, m_pRun, sizeof( ULONG ) );
 257     m_pRun += sizeof( ULONG );
 258     return nCount;
 259 }
 260
 261 void* MediatorMessage::GetBytes( ULONG& rBytes )
 262 {
 263     if( ! m_pRun )
 264         m_pRun = m_pBytes;
 265
 266     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetBytes\n" );
 267     ULONG nBytes = ExtractULONG();
 268
 269     if( nBytes == 0 )
 270         return NULL;
 271
 272     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetBytes\n" );
 273     char* pBuffer = new char[ nBytes ];
 274     memcpy( pBuffer, m_pRun, nBytes );
 275     m_pRun += nBytes;
 276     rBytes = nBytes;
 277     return pBuffer;
 278 }
 279
 280 char* MediatorMessage::GetString()
 281 {
 282     if( ! m_pRun )
 283         m_pRun = m_pBytes;
 284
 285     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetString\n" );
 286     ULONG nBytes = ExtractULONG();
 287
 288     if( nBytes == 0 )
 289         return NULL;
 290
 291     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetString\n" );
 292     char* pBuffer = new char[ nBytes+1 ];
 293     memcpy( pBuffer, m_pRun, nBytes );
 294     pBuffer[ nBytes ] = 0;
 295     m_pRun += nBytes;
 296     return pBuffer;
 297 }
 298
 299 UINT32 MediatorMessage::GetUINT32()
 300 {
 301     if( ! m_pRun )
 302         m_pRun = m_pBytes;
 303
 304     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetUINT32\n" );
 305     ULONG nBytes = ExtractULONG();
 306     medDebug( nBytes != sizeof( UINT32 ), "No UINT32 in MediatorMessage::GetUINT32\n" );
 307     medDebug( (ULONG)(m_pRun - m_pBytes) >= m_nBytes, "Overflow in MediatorMessage::GetUINT32\n" );
 308     UINT32 nRet;
 309     memcpy( &nRet, m_pRun, sizeof( nRet ) );
 310     m_pRun += sizeof( UINT32 );
 311     return nRet;
 312 }