bridges/source/remote/urp/urp_unmarshal.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: urp_unmarshal.cxx,v $
  10  * $Revision: 1.16 $
  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_bridges.hxx"
  33 #include <string.h>
  34
  35 #include <osl/diagnose.h>
  36
  37 #include <rtl/alloc.h>
  38 #include <rtl/ustrbuf.hxx>
  39
  40 #include <uno/data.h>
  41 #include <uno/any2.h>
  42 #include <uno/sequence2.h>
  43
  44 #include <com/sun/star/uno/Any.hxx>
  45
  46 #include "urp_unmarshal.hxx"
  47 #include "urp_bridgeimpl.hxx"
  48
  49
  50 using namespace ::rtl;
  51 using namespace ::com::sun::star::uno;
  52
  53 namespace bridges_urp
  54 {
  55 static int g_nDetectLittleEndian = 1;
  56 char g_bSystemIsLittleEndian = ((char*)&g_nDetectLittleEndian)[0];
  57
  58
  59 Unmarshal::Unmarshal( struct urp_BridgeImpl *pBridgeImpl,
  60                       uno_Environment *pEnvRemote,
  61                       remote_createStubFunc callback ) :
  62     m_nBufferSize( 4096 ),
  63     m_base( (sal_Int8*) rtl_allocateMemory( m_nBufferSize ) ),
  64     m_pos( m_base ),
  65     m_nLength( 0 ),
  66     m_callback( callback ),
  67     m_pEnvRemote( pEnvRemote ),
  68     m_pBridgeImpl( pBridgeImpl )
  69 {
  70 }
  71
  72 Unmarshal::~Unmarshal()
  73 {
  74     rtl_freeMemory( m_base );
  75 }
  76
  77 // special unpacks
  78 sal_Bool Unmarshal::unpackTid( sal_Sequence **ppThreadId )
  79 {
  80     sal_Int32 nSize;
  81     sal_Bool bReturn = unpackCompressedSize( &nSize );
  82     if( bReturn )
  83     {
  84         if( nSize )
  85         {
  86             rtl_byte_sequence_constructFromArray( ppThreadId , m_pos , nSize );
  87             m_pos += nSize;
  88             sal_uInt16 nIndex;
  89             bReturn = unpackInt16( &nIndex );
  90             if( nIndex < m_pBridgeImpl->m_properties.nTidCacheSize )
  91             {
  92                 m_pBridgeImpl->m_pTidIn[nIndex] = *(ByteSequence * )ppThreadId;
  93             }
  94             else if( 0xffff != nIndex )
  95             {
  96                 bReturn = sal_False;
  97                 rtl_byte_sequence_construct( ppThreadId , 0 );
  98
  99                 OUStringBuffer error( 128 );
 100                 error.appendAscii( "cache index for tid " );
 101                 OString o = byteSequence2HumanReadableString( *(ByteSequence * ) ppThreadId );
 102                 error.appendAscii( o.getStr(), o.getLength() );
 103                 error.appendAscii( "out of range(0x");
 104                 error.append(  (sal_Int32) nIndex ,16 );
 105                 error.appendAscii( ")" );
 106                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 107             }
 108         }
 109         else
 110         {
 111             sal_uInt16 nIndex;
 112             bReturn = unpackInt16( &nIndex );
 113             if( nIndex < m_pBridgeImpl->m_properties.nTidCacheSize )
 114             {
 115                 *ppThreadId = m_pBridgeImpl->m_pTidIn[nIndex].getHandle();
 116                 rtl_byte_sequence_acquire( *ppThreadId );
 117             }
 118             else
 119             {
 120                 bReturn = sal_False;
 121                 rtl_byte_sequence_construct( ppThreadId , 0 );
 122                 OUStringBuffer error(128);
 123                 error.appendAscii( "cache index for tids out of range(0x" );
 124                 error.append( (sal_Int32) nIndex ,16 );
 125                 error.appendAscii( ")" );
 126                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 127             }
 128         }
 129     }
 130     else
 131     {
 132         m_pBridgeImpl->addError( "couldn't unpack thread id because of previous errors" );
 133     }
 134     return bReturn;
 135 }
 136
 137 sal_Bool Unmarshal::unpackOid( rtl_uString **ppOid )
 138 {
 139     sal_Bool bReturn = sal_True;
 140     sal_uInt16 nCacheIndex = 0;
 141
 142     bReturn = bReturn && unpackString( ppOid );
 143     bReturn = bReturn && unpackInt16( &nCacheIndex );
 144
 145     if( bReturn &&
 146         ! ( 0xffff == nCacheIndex && 0 == (*ppOid)->length ) /* null reference */  )
 147     {
 148         if( (*ppOid)->length )
 149         {
 150             // new unknown reference
 151             if( 0xffff != nCacheIndex )
 152             {
 153                 // oid should be cached ?
 154                 if( nCacheIndex < m_pBridgeImpl->m_properties.nOidCacheSize )
 155                 {
 156                     m_pBridgeImpl->m_pOidIn[nCacheIndex] = *ppOid;
 157                 }
 158                 else
 159                 {
 160                     OUStringBuffer error( 128 );
 161                     error.appendAscii( "new oid provided (" );
 162                     error.append( *ppOid );
 163                     error.appendAscii( "), but new cache index is out of range(0x");
 164                     error.append(  (sal_Int32) nCacheIndex ,16 );
 165                     error.appendAscii( ")" );
 166                     m_pBridgeImpl->addError( error.makeStringAndClear() );
 167
 168                     bReturn = sal_False;
 169                     rtl_uString_new( ppOid );
 170                 }
 171             }
 172         }
 173         else
 174         {
 175             // reference in cache !
 176             if( nCacheIndex < m_pBridgeImpl->m_properties.nOidCacheSize )
 177             {
 178                 rtl_uString_assign( ppOid , m_pBridgeImpl->m_pOidIn[nCacheIndex].pData );
 179             }
 180             else
 181             {
 182                 bReturn = sal_False;
 183                 rtl_uString_new( ppOid );
 184
 185                 OUStringBuffer error( 128 );
 186                 error.appendAscii( "cache index for oids out of range(0x");
 187                 error.append(  (sal_Int32) nCacheIndex ,16 );
 188                 error.appendAscii( ")" );
 189                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 190             }
 191         }
 192     }
 193
 194     return bReturn;
 195 }
 196
 197 sal_Bool Unmarshal::unpack( void *pDestination ,
 198                             typelib_TypeDescription *pTypeDescr )
 199 {
 200     // Note: We implement unpack functionality without recursions in order
 201     //       to avoid stack overflows caused by rotten URP blocks.
 202
 203     m_aItemsToUnpack.push( UnpackItem( pDestination, pTypeDescr ) );
 204
 205     sal_Bool bReturn = sal_True;
 206     do
 207     {
 208         void * pDest = m_aItemsToUnpack.top().pDest;
 209         typelib_TypeDescription * pType = m_aItemsToUnpack.top().pType;
 210         m_aItemsToUnpack.pop();
 211
 212         switch( pType->eTypeClass )
 213         {
 214         case typelib_TypeClass_VOID:
 215             // do nothing
 216             break;
 217         case typelib_TypeClass_BYTE:
 218         {
 219             bReturn = unpackInt8( pDest );
 220             break;
 221         }
 222         case typelib_TypeClass_BOOLEAN:
 223         {
 224             bReturn = ! checkOverflow( 1 );
 225             if( bReturn )
 226             {
 227                 *((sal_Bool*)pDest) = (sal_Bool ) ( *m_pos);
 228                 m_pos ++;
 229             }
 230             else
 231             {
 232                 *((sal_Bool*)pDest) = 0;
 233             }
 234             break;
 235         }
 236
 237         case typelib_TypeClass_CHAR:
 238         case typelib_TypeClass_SHORT:
 239         case typelib_TypeClass_UNSIGNED_SHORT:
 240         {
 241             unpackInt16( pDest );
 242             break;
 243         }
 244         case typelib_TypeClass_ENUM:
 245         case typelib_TypeClass_FLOAT:
 246         case typelib_TypeClass_LONG:
 247         case typelib_TypeClass_UNSIGNED_LONG:
 248         {
 249             bReturn = unpackInt32( pDest );
 250             break;
 251         }
 252         case typelib_TypeClass_DOUBLE:
 253         case typelib_TypeClass_HYPER:
 254         case typelib_TypeClass_UNSIGNED_HYPER:
 255         {
 256             sal_Int8 * p = static_cast<  sal_Int8 * >(pDest);
 257             bReturn = ! checkOverflow( 8 );
 258             if( bReturn )
 259             {
 260                 if( isSystemLittleEndian() )
 261                 {
 262                     p[7] = m_pos[0];
 263                     p[6] = m_pos[1];
 264                     p[5] = m_pos[2];
 265                     p[4] = m_pos[3];
 266                     p[3] = m_pos[4];
 267                     p[2] = m_pos[5];
 268                     p[1] = m_pos[6];
 269                     p[0] = m_pos[7];
 270                 }
 271                 else
 272                 {
 273                     p[0] = m_pos[0];
 274                     p[1] = m_pos[1];
 275                     p[2] = m_pos[2];
 276                     p[3] = m_pos[3];
 277                     p[4] = m_pos[4];
 278                     p[5] = m_pos[5];
 279                     p[6] = m_pos[6];
 280                     p[7] = m_pos[7];
 281                 }
 282                 m_pos += 8;
 283             }
 284             else
 285             {
 286                 // Do not trigger alignment errors:
 287                 p[0] = p[1] = p[2] = p[3] = p[4] = p[5] = p[6] = p[7] = 0;
 288             }
 289             break;
 290         }
 291         case typelib_TypeClass_STRING:
 292         {
 293             unpackString( pDest );
 294             break;
 295         }
 296         case typelib_TypeClass_ANY:
 297         {
 298             uno_Any *pAny = ( uno_Any * )pDest;
 299
 300             pAny->pType = 0;
 301             // Type is acquired with typelib_typedescription_acquire
 302
 303             bReturn = unpackType( &(pAny->pType) );
 304
 305             typelib_TypeDescription *pDataType = 0;
 306             if( bReturn && pAny->pType )
 307             {
 308                 typelib_typedescriptionreference_getDescription( &pDataType , pAny->pType );
 309
 310                 if( pDataType )
 311                 {
 312                     switch (pDataType->eTypeClass)
 313                     {
 314                     case typelib_TypeClass_HYPER:
 315                     case typelib_TypeClass_UNSIGNED_HYPER:
 316                         if (sizeof(void *) < sizeof(sal_Int64))
 317                         {
 318                             pAny->pData = rtl_allocateMemory( sizeof(sal_Int64) );
 319                         }
 320                         else
 321                         {
 322                             pAny->pData = &pAny->pReserved;
 323                         }
 324                         break;
 325                     case typelib_TypeClass_FLOAT:
 326                         if (sizeof(void *) < sizeof(float))
 327                         {
 328                             pAny->pData = rtl_allocateMemory( sizeof(float) );
 329                         }
 330                         else
 331                         {
 332                             pAny->pData = &pAny->pReserved;
 333                         }
 334                         break;
 335                     case typelib_TypeClass_DOUBLE:
 336                         if (sizeof(void *) < sizeof(double))
 337                         {
 338                             pAny->pData = rtl_allocateMemory( sizeof(double) );
 339                         }
 340                         else
 341                         {
 342                             pAny->pData = &pAny->pReserved;
 343                         }
 344                         break;
 345                     case typelib_TypeClass_STRUCT:
 346                     case typelib_TypeClass_UNION:
 347                     case typelib_TypeClass_EXCEPTION:
 348                     case typelib_TypeClass_ARRAY:
 349                         pAny->pData = rtl_allocateMemory( pDataType->nSize );
 350                         break;
 351                     case typelib_TypeClass_ANY:
 352                     {
 353                         m_pBridgeImpl->addError(
 354                             OUString( RTL_CONSTASCII_USTRINGPARAM(
 355                                 "can't unmarshal any: any in any not supported!" ) ) );
 356
 357                         pAny->pData = 0;
 358                         Type type; // void
 359                         pAny->pType = type.getTypeLibType();
 360                         typelib_typedescriptionreference_acquire( pAny->pType );
 361
 362                         bReturn = sal_False;
 363                         break;
 364                     }
 365                     default:
 366                         pAny->pData = &pAny->pReserved;
 367                     }
 368
 369                     if ( bReturn )
 370                     {
 371                         m_aItemsToUnpack.push(
 372                             UnpackItem( pAny->pData, pDataType ) );
 373                     }
 374                 }
 375                 else
 376                 {
 377                     OUStringBuffer error;
 378                     error.appendAscii( "can't unmarshal any because typedescription for " );
 379                     error.append( pAny->pType->pTypeName );
 380                     error.appendAscii( " is missing" );
 381                     m_pBridgeImpl->addError( error.makeStringAndClear() );
 382                 }
 383             }
 384
 385             if( pDataType )
 386             {
 387                 typelib_typedescription_release( pDataType );
 388             }
 389             else
 390             {
 391                 pAny->pData = 0;
 392                 Type type; // void
 393                 pAny->pType = type.getTypeLibType();
 394                 typelib_typedescriptionreference_acquire( pAny->pType );
 395
 396                 bReturn = sal_False;
 397             }
 398
 399             break;
 400         }
 401         case typelib_TypeClass_INTERFACE:
 402         {
 403             *(remote_Interface**)pDest = 0;
 404
 405             rtl_uString *pString = 0;
 406             bReturn = unpackOid( &pString ) && bReturn;
 407
 408             if( bReturn && pString && pString->length )
 409             {
 410                 m_callback( (remote_Interface**) pDest ,
 411                             pString,
 412                             pType->pWeakRef ,
 413                             m_pEnvRemote,
 414                             urp_releaseRemoteCallback );
 415             }
 416             if( pString )
 417             {
 418                 rtl_uString_release( pString );
 419             }
 420             break;
 421         }
 422         case typelib_TypeClass_TYPE:
 423         {
 424             bReturn = unpackType( pDest );
 425             break;
 426         }
 427         case typelib_TypeClass_STRUCT:
 428         case typelib_TypeClass_EXCEPTION:
 429         {
 430             typelib_CompoundTypeDescription * pCompType =
 431                 (typelib_CompoundTypeDescription *)pType;
 432
 433             // direct members
 434             typelib_TypeDescriptionReference ** ppTypeRefs = pCompType->ppTypeRefs;
 435             sal_Int32 * pMemberOffsets = pCompType->pMemberOffsets;
 436             sal_Int32 nDescr = pCompType->nMembers;
 437
 438             // at least assume 1 byte per member
 439             bReturn = bReturn && ! checkOverflow( nDescr * 1 );
 440             for ( sal_Int32 nPos = nDescr; nPos; --nPos )
 441             {
 442                 typelib_TypeDescription * pMemberType = 0;
 443                 typelib_typedescriptionreference_getDescription(
 444                     &pMemberType, ppTypeRefs[ nPos - 1 ] );
 445
 446                 m_aItemsToUnpack.push(
 447                     UnpackItem( (char*)pDest + pMemberOffsets[ nPos - 1 ],
 448                                 pMemberType,
 449                                 true /* construct even in error case */ ) );
 450
 451                 m_aTypesToRelease.push_back( pMemberType );
 452             }
 453
 454             // parent
 455             if (pCompType->pBaseTypeDescription)
 456             {
 457                 m_aItemsToUnpack.push(
 458                     UnpackItem( pDest,
 459                                 (typelib_TypeDescription *)
 460                                     pCompType->pBaseTypeDescription ) );
 461             }
 462             break;
 463         }
 464         case typelib_TypeClass_SEQUENCE:
 465         {
 466             sal_Int32 nLen;
 467             bReturn = unpackCompressedSize( &nLen );
 468
 469             // urp protocol does not allow to use the elementsize as a guess, if enough data
 470             // is available. However, at least one byte per member must be within the message
 471             bReturn = bReturn && ! checkOverflow( 1 * nLen );
 472             uno_Sequence *pSequence = 0;
 473             if( nLen && bReturn )
 474             {
 475                 typelib_TypeDescriptionReference * pETRef =
 476                     ((typelib_IndirectTypeDescription *)pType)->pType;
 477
 478                 typelib_TypeDescription * pET = 0;
 479                 typelib_typedescriptionreference_getDescription( &pET , pETRef );
 480
 481                 if( pET )
 482                 {
 483                     sal_Int32 nElementSize = pET->nSize;
 484
 485                     pSequence = (uno_Sequence *)rtl_allocateMemory(
 486                         SAL_SEQUENCE_HEADER_SIZE + nElementSize * nLen );
 487                     pSequence->nRefCount = 1;
 488                     pSequence->nElements = nLen;
 489
 490                     if( typelib_TypeClass_BYTE == pET->eTypeClass )
 491                     {
 492                         memcpy( pSequence->elements , m_pos , nLen );
 493                         m_pos += nLen;
 494                     }
 495                     else
 496                     {
 497                         for ( sal_Int32 i = nLen; i; --i )
 498                         {
 499                             m_aItemsToUnpack.push(
 500                                 UnpackItem(
 501                                     ((char*)pSequence->elements)
 502                                         + (i - 1) * nElementSize,
 503                                     pET ) );
 504                         }
 505                     }
 506                     m_aTypesToRelease.push_back( pET );
 507                 }
 508                 else
 509                 {
 510                     bReturn = sal_False;
 511                     uno_constructData( &pSequence , pType );
 512                     OUStringBuffer error;
 513                     error.appendAscii( "can't unmarshal sequence, because there is no typedescription for element type " );
 514                     error.append( pETRef->pTypeName );
 515                     error.appendAscii( " available" );
 516                     m_pBridgeImpl->addError( error.makeStringAndClear() );
 517                 }
 518             }
 519             else
 520             {
 521                 uno_constructData( &pSequence , pType );
 522             }
 523
 524             *((uno_Sequence **)pDest) = pSequence;
 525             break;
 526         }
 527         case typelib_TypeClass_UNION:
 528         case typelib_TypeClass_ARRAY:
 529         case typelib_TypeClass_SERVICE:
 530         case typelib_TypeClass_MODULE:
 531         case typelib_TypeClass_INTERFACE_METHOD:
 532         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
 533         case typelib_TypeClass_UNKNOWN:
 534         default:
 535         {
 536             ::rtl::OUStringBuffer buffer( 128 );
 537             buffer.appendAscii( RTL_CONSTASCII_STRINGPARAM("Unsupported typeclass during unmarshaling ("));
 538             buffer.append( ( sal_Int32 ) pType->eTypeClass , 10 );
 539             buffer.appendAscii( ")" );
 540             m_pBridgeImpl->addError( buffer.makeStringAndClear() );
 541             bReturn = sal_False;
 542         }
 543         }
 544
 545         if ( !bReturn )
 546         {
 547             // construct default data for every remaining item.
 548             while ( !m_aItemsToUnpack.empty() )
 549             {
 550                 const UnpackItem & rItem = m_aItemsToUnpack.top();
 551
 552                 if ( rItem.bMustBeConstructed )
 553                     uno_constructData( rItem.pDest , rItem.pType );
 554
 555                 m_aItemsToUnpack.pop();
 556             }
 557         }
 558     }
 559     while ( !m_aItemsToUnpack.empty() );
 560
 561     // release pending type descriptions
 562     TypeDescVector::const_iterator it = m_aTypesToRelease.begin();
 563     const TypeDescVector::const_iterator end = m_aTypesToRelease.end();
 564     while ( it != end )
 565     {
 566         typelib_typedescription_release( *it );
 567         it++;
 568     }
 569     m_aTypesToRelease.clear();
 570
 571     return bReturn;
 572 }
 573
 574 sal_Bool Unmarshal::unpackType( void *pDest )
 575 {
 576     *(typelib_TypeDescriptionReference **) pDest = 0;
 577
 578     sal_uInt8 nTypeClass;
 579     sal_Bool bReturn = unpackInt8( &nTypeClass );
 580
 581     typelib_TypeDescriptionReference *pTypeRef = 0;
 582     if( bReturn )
 583     {
 584         if( nTypeClass <= 14 /* any */ )
 585         {
 586             pTypeRef = * typelib_static_type_getByTypeClass((typelib_TypeClass )nTypeClass);
 587             typelib_typedescriptionreference_acquire( pTypeRef );
 588         }
 589         else
 590         {
 591             sal_uInt16 nCacheIndex = 0;
 592             bReturn = bReturn && unpackInt16( &nCacheIndex  );
 593
 594             if( bReturn )
 595             {
 596                 if( nTypeClass & 0x80 )
 597                 {
 598                     // new type
 599                     rtl_uString *pString = 0;
 600                     bReturn = bReturn && unpackString( &pString );
 601                     if( bReturn )
 602                     {
 603                         typelib_TypeDescription *pType = 0;
 604                         typelib_typedescription_getByName( &pType, pString );
 605                         if( pType )
 606                         {
 607                             // type is known in this process
 608                             if( (typelib_TypeClass )(nTypeClass & 0x7f) == pType->eTypeClass )
 609                             {
 610                                 //typename and typeclass match, this is as it should be
 611                                 pTypeRef = pType->pWeakRef;
 612                                 typelib_typedescriptionreference_acquire( pTypeRef );
 613                             }
 614                             else
 615                             {
 616                                 // typename and typeclass do not match, dispose the bridge
 617                                 // as there must be inconsistent type base between both processes
 618                                 // or trash comes over the wire ...
 619                                 bReturn = sal_False;
 620                                 OUStringBuffer error( 128 );
 621                                 error.appendAscii( "it is tried to introduce type " );
 622                                 error.append( pString );
 623                                 error.appendAscii( "with typeclass " );
 624                                 error.append( (sal_Int32)( nTypeClass & 0x7f ) , 10 );
 625                                 error.appendAscii( " , which does not match with typeclass " );
 626                                 error.append(  (sal_Int32) pType->eTypeClass ,10 );
 627                                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 628                             }
 629                             typelib_typedescription_release( pType );
 630                             pType = 0;
 631                         }
 632                         else
 633                         {
 634                             // a type by this name is not known in the process.
 635                             if( (nTypeClass & 0x7f) < typelib_TypeClass_UNKNOWN )
 636                             {
 637                                 // typeclass is within a valid range, introduce the new
 638                                 // type.
 639                                 typelib_typedescriptionreference_new(
 640                                     &pTypeRef, (typelib_TypeClass )(nTypeClass & 0x7f), pString );
 641                             }
 642                             else
 643                             {
 644                                 // typeclass is out of range !
 645                                 bReturn = sal_False;
 646                                 OUStringBuffer error( 128 );
 647                                 error.appendAscii( "it is tried to introduce type " );
 648                                 error.append( pString );
 649                                 error.appendAscii( "with an out of range typeclass " );
 650                                 error.append( (sal_Int32)( nTypeClass & 0x7f ) , 10 );
 651                                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 652                             }
 653                         }
 654
 655                         if( bReturn && nCacheIndex != 0xffff )
 656                         {
 657                             if( nCacheIndex < m_pBridgeImpl->m_properties.nTypeCacheSize )
 658                             {
 659                                 m_pBridgeImpl->m_pTypeIn[nCacheIndex] = *( Type * )&pTypeRef;
 660                             }
 661                             else
 662                             {
 663                                 bReturn = sal_False;
 664                                 OUStringBuffer error( 128 );
 665                                 error.appendAscii( "cache index for type " );
 666                                 error.append( pString );
 667                                 error.appendAscii( "out of range(0x" );
 668                                 error.append( (sal_Int32) nCacheIndex ,16 );
 669                                 error.appendAscii( ")" );
 670                                 m_pBridgeImpl->addError( error.makeStringAndClear() );
 671                             }
 672                         }
 673                     }
 674                     if( pString )
 675                     {
 676                         rtl_uString_release( pString );
 677                     }
 678                 }
 679                 else
 680                 {
 681                     if( nCacheIndex < m_pBridgeImpl->m_properties.nTypeCacheSize )
 682                     {
 683                         pTypeRef = m_pBridgeImpl->m_pTypeIn[nCacheIndex].getTypeLibType();
 684                         typelib_typedescriptionreference_acquire( pTypeRef );
 685                     }
 686                     else
 687                     {
 688                         bReturn = sal_False;
 689                         OUStringBuffer error;
 690                         error.appendAscii( "cache index for types out of range(0x" );
 691                         error.append( (sal_Int32) nCacheIndex ,16 );
 692                         error.appendAscii( ")" );
 693                         m_pBridgeImpl->addError( error.makeStringAndClear() );
 694                     }
 695                 }
 696             }
 697         }
 698     }
 699     if( ! pTypeRef )
 700     {
 701         pTypeRef = * typelib_static_type_getByTypeClass(typelib_TypeClass_VOID);
 702         typelib_typedescriptionreference_acquire( pTypeRef );
 703     }
 704     // pTypeRef is already acquired
 705     *(typelib_TypeDescriptionReference**)pDest = pTypeRef;
 706     return bReturn;
 707 }
 708
 709 }
 710