| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "sal/config.h" | |
| #include <exception> | |
| #include <memory> | |
| #include <vector> | |
| #include "com/sun/star/connection/XConnection.hpp" | |
| #include "com/sun/star/io/IOException.hpp" | |
| #include "com/sun/star/uno/Any.hxx" | |
| #include "com/sun/star/uno/Exception.hpp" | |
| #include "com/sun/star/uno/Reference.hxx" | |
| #include "com/sun/star/uno/RuntimeException.hpp" | |
| #include "com/sun/star/uno/Sequence.hxx" | |
| #include "com/sun/star/uno/Type.hxx" | |
| #include "com/sun/star/uno/XCurrentContext.hpp" | |
| #include "com/sun/star/uno/XInterface.hpp" | |
| #include "cppu/unotype.hxx" | |
| #include "osl/diagnose.h" | |
| #include "rtl/byteseq.h" | |
| #include "rtl/string.h" | |
| #include "rtl/textenc.h" | |
| #include "rtl/ustring.h" | |
| #include "rtl/ustring.hxx" | |
| #include "sal/types.h" | |
| #include "typelib/typeclass.h" | |
| #include "typelib/typedescription.h" | |
| #include "typelib/typedescription.hxx" | |
| #include "uno/lbnames.h" | |
| #include "binaryany.hxx" | |
| #include "bridge.hxx" | |
| #include "incomingreply.hxx" | |
| #include "incomingrequest.hxx" | |
| #include "outgoingrequest.hxx" | |
| #include "reader.hxx" | |
| #include "specialfunctionids.hxx" | |
| #include "unmarshal.hxx" | |
| namespace binaryurp { | |
| namespace { | |
| namespace css = com::sun::star; | |
| css::uno::Sequence< sal_Int8 > read( | |
| css::uno::Reference< css::connection::XConnection > const & connection, | |
| sal_uInt32 size, bool eofOk) | |
| { | |
| OSL_ASSERT(connection.is()); | |
| if (size > SAL_MAX_INT32) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "binaryurp::Reader: block size too large")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| css::uno::Sequence< sal_Int8 > buf; | |
| sal_Int32 n = connection->read(buf, static_cast< sal_Int32 >(size)); | |
| if (n == 0 && eofOk) { | |
| return css::uno::Sequence< sal_Int8 >(); | |
| } | |
| if (n != static_cast< sal_Int32 >(size)) { | |
| throw css::io::IOException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "binaryurp::Reader: premature end of input")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| OSL_ASSERT(buf.getLength() == static_cast< sal_Int32 >(size)); | |
| return buf; | |
| } | |
| extern "C" void SAL_CALL request(void * pThreadSpecificData) { | |
| OSL_ASSERT(pThreadSpecificData != 0); | |
| std::unique_ptr< IncomingRequest >( | |
| static_cast< IncomingRequest * >(pThreadSpecificData))-> | |
| execute(); | |
| } | |
| } | |
| Reader::Reader(rtl::Reference< Bridge > const & bridge): bridge_(bridge) { | |
| OSL_ASSERT(bridge.is()); | |
| acquire(); | |
| } | |
| Reader::~Reader() {} | |
| void Reader::run() { | |
| setName("binaryurpReader"); | |
| try { | |
| bridge_->sendRequestChangeRequest(); | |
| css::uno::Reference< css::connection::XConnection > con( | |
| bridge_->getConnection()); | |
| for (;;) { | |
| css::uno::Sequence< sal_Int8 > s(read(con, 8, true)); | |
| if (s.getLength() == 0) { | |
| break; | |
| } | |
| Unmarshal header(bridge_, state_, s); | |
| sal_uInt32 size = header.read32(); | |
| sal_uInt32 count = header.read32(); | |
| header.done(); | |
| if (count == 0) { | |
| throw css::io::IOException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "binaryurp::Reader: block with zero message count" | |
| " received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| Unmarshal block(bridge_, state_, read(con, size, false)); | |
| for (sal_uInt32 i = 0; i != count; ++i) { | |
| readMessage(block); | |
| } | |
| block.done(); | |
| } | |
| } catch (css::uno::Exception & e) { | |
| OSL_TRACE( | |
| OSL_LOG_PREFIX "caught UNO exception '%s'", | |
| rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr()); | |
| } catch (std::exception & e) { | |
| OSL_TRACE(OSL_LOG_PREFIX "caught C++ exception '%s'", e.what()); | |
| } | |
| bridge_->terminate(); | |
| } | |
| void Reader::onTerminated() { | |
| release(); | |
| } | |
| void Reader::readMessage(Unmarshal & unmarshal) { | |
| sal_uInt8 flags1 = unmarshal.read8(); | |
| bool newType; | |
| bool newOid; | |
| bool newTid; | |
| bool forceSynchronous; | |
| sal_uInt16 functionId; | |
| if ((flags1 & 0x80) != 0) { // bit 7: LONGHEADER | |
| if ((flags1 & 0x40) == 0) { // bit 6: REQUEST | |
| readReplyMessage(unmarshal, flags1); | |
| return; | |
| } | |
| newType = (flags1 & 0x20) != 0; // bit 5: NEWTYPE | |
| newOid = (flags1 & 0x10) != 0; // bit 4: NEWOID | |
| newTid = (flags1 & 0x08) != 0; // bit 3: NEWTID | |
| if ((flags1 & 0x01) != 0) { // bit 0: MOREFLAGSS | |
| sal_uInt8 flags2 = unmarshal.read8(); | |
| forceSynchronous = (flags2 & 0x80) != 0; // bit 7: MUSTREPLY | |
| if (((flags2 & 0x40) != 0) != forceSynchronous) { | |
| // bit 6: SYNCHRONOUS | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with MUSTREPLY != SYNCHRONOUS" | |
| " received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } else { | |
| forceSynchronous = false; | |
| } | |
| functionId = ((flags1 & 0x04) != 0) // bit 2: FUNCTIONID16 | |
| ? unmarshal.read16() : unmarshal.read8(); | |
| } else { | |
| newType = false; | |
| newOid = false; | |
| newTid = false; | |
| forceSynchronous = false; | |
| functionId = ((flags1 & 0x40) != 0) // bit 6: FUNCTIONID14 | |
| ? ((flags1 & 0x3F) << 8) | unmarshal.read8() : flags1 & 0x3F; | |
| } | |
| css::uno::TypeDescription type; | |
| if (newType) { | |
| type = unmarshal.readType(); | |
| lastType_ = type; | |
| } else { | |
| if (!lastType_.is()) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with NEWTYPE received when last" | |
| " interface type has not yet been set")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| type = lastType_; | |
| } | |
| rtl::OUString oid; | |
| if (newOid) { | |
| oid = unmarshal.readOid(); | |
| if ( oid.isEmpty() ) { | |
| throw css::io::IOException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "binaryurp::Unmarshal: emtpy OID")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| lastOid_ = oid; | |
| } else { | |
| if ( lastOid_.isEmpty() ) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with NEWOID received when last" | |
| " OID has not yet been set")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| oid = lastOid_; | |
| } | |
| rtl::ByteSequence tid(getTid(unmarshal, newTid)); | |
| lastTid_ = tid; | |
| type.makeComplete(); | |
| if (type.get()->eTypeClass != typelib_TypeClass_INTERFACE) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with non-interface interface type" | |
| " received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| typelib_InterfaceTypeDescription * itd = | |
| reinterpret_cast< typelib_InterfaceTypeDescription * >(type.get()); | |
| if (functionId >= itd->nMapFunctionIndexToMemberIndex) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with unknown function ID received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| sal_Int32 memberId = itd->pMapFunctionIndexToMemberIndex[functionId]; | |
| css::uno::TypeDescription memberTd(itd->ppAllMembers[memberId]); | |
| memberTd.makeComplete(); | |
| OSL_ASSERT(memberTd.is()); | |
| bool protProps = bridge_->isProtocolPropertiesRequest(oid, type); | |
| bool ccMode = !protProps && functionId != SPECIAL_FUNCTION_ID_RELEASE && | |
| bridge_->isCurrentContextMode(); | |
| css::uno::UnoInterfaceReference cc; | |
| if (ccMode) { | |
| css::uno::TypeDescription t( | |
| cppu::UnoType< css::uno::Reference< css::uno::XCurrentContext > >:: | |
| get()); | |
| cc.set( | |
| *static_cast< uno_Interface ** >( | |
| unmarshal.readValue(t).getValue(t))); | |
| } | |
| bool synchronous; | |
| if (memberTd.get()->eTypeClass == typelib_TypeClass_INTERFACE_METHOD && | |
| (reinterpret_cast< typelib_InterfaceMethodTypeDescription * >( | |
| memberTd.get())-> | |
| bOneWay)) | |
| { | |
| synchronous = forceSynchronous; | |
| } else { | |
| if (forceSynchronous) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: synchronous request message with non-oneway" | |
| " function ID received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| synchronous = true; | |
| } | |
| bool setter = false; | |
| std::vector< BinaryAny > inArgs; | |
| switch (memberTd.get()->eTypeClass) { | |
| case typelib_TypeClass_INTERFACE_ATTRIBUTE: | |
| setter = itd->pMapMemberIndexToFunctionIndex[memberId] != functionId; | |
| // pMapMemberIndexToFunctionIndex contains function index of | |
| // attribute getter | |
| if (setter) { | |
| inArgs.push_back( | |
| unmarshal.readValue( | |
| css::uno::TypeDescription( | |
| reinterpret_cast< | |
| typelib_InterfaceAttributeTypeDescription * >( | |
| memberTd.get())-> | |
| pAttributeTypeRef))); | |
| } | |
| break; | |
| case typelib_TypeClass_INTERFACE_METHOD: | |
| { | |
| typelib_InterfaceMethodTypeDescription * mtd = | |
| reinterpret_cast< typelib_InterfaceMethodTypeDescription * >( | |
| memberTd.get()); | |
| for (sal_Int32 i = 0; i != mtd->nParams; ++i) { | |
| if (mtd->pParams[i].bIn) { | |
| inArgs.push_back( | |
| unmarshal.readValue( | |
| css::uno::TypeDescription( | |
| mtd->pParams[i].pTypeRef))); | |
| } | |
| } | |
| break; | |
| } | |
| default: | |
| OSL_ASSERT(false); // this cannot happen | |
| break; | |
| } | |
| bridge_->incrementCalls( | |
| !protProps && functionId != SPECIAL_FUNCTION_ID_RELEASE); | |
| if (protProps) { | |
| switch (functionId) { | |
| case SPECIAL_FUNCTION_ID_REQUEST_CHANGE: | |
| bridge_->handleRequestChangeRequest(tid, inArgs); | |
| break; | |
| case SPECIAL_FUNCTION_ID_COMMIT_CHANGE: | |
| bridge_->handleCommitChangeRequest(tid, inArgs); | |
| break; | |
| default: | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with UrpProtocolProperties OID" | |
| " and unknown function ID received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } else { | |
| css::uno::UnoInterfaceReference obj; | |
| switch (functionId) { | |
| case SPECIAL_FUNCTION_ID_QUERY_INTERFACE: | |
| obj = bridge_->findStub(oid, type); | |
| if (!obj.is()) { | |
| OSL_ASSERT( | |
| inArgs.size() == 1 | |
| && inArgs[0].getType().equals( | |
| css::uno::TypeDescription( | |
| cppu::UnoType< css::uno::Type >::get()))); | |
| if (!(type.equals( | |
| css::uno::TypeDescription( | |
| cppu::UnoType< | |
| css::uno::Reference< | |
| css::uno::XInterface > >::get())) | |
| && (css::uno::TypeDescription( | |
| *static_cast< | |
| typelib_TypeDescriptionReference ** >( | |
| inArgs[0].getValue(inArgs[0].getType()))). | |
| equals( | |
| css::uno::TypeDescription( | |
| cppu::UnoType< | |
| css::uno::Reference< | |
| css::uno::XInterface > >::get()))))) | |
| { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: queryInterface request message with" | |
| " unknown OID received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| break; | |
| case SPECIAL_FUNCTION_ID_RESERVED: | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with unknown function ID 1" | |
| " received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case SPECIAL_FUNCTION_ID_RELEASE: | |
| break; | |
| default: | |
| obj = bridge_->findStub(oid, type); | |
| if (!obj.is()) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: request message with unknown OID received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| break; | |
| } | |
| std::unique_ptr< IncomingRequest > req( | |
| new IncomingRequest( | |
| bridge_, tid, oid, obj, type, functionId, synchronous, memberTd, | |
| setter, inArgs, ccMode, cc)); | |
| if (synchronous) { | |
| bridge_->incrementActiveCalls(); | |
| } | |
| uno_threadpool_putJob( | |
| bridge_->getThreadPool(), tid.getHandle(), req.get(), &request, | |
| !synchronous); | |
| req.release(); | |
| } | |
| } | |
| void Reader::readReplyMessage(Unmarshal & unmarshal, sal_uInt8 flags1) { | |
| rtl::ByteSequence tid(getTid(unmarshal, (flags1 & 0x08) != 0)); | |
| // bit 3: NEWTID | |
| lastTid_ = tid; | |
| OutgoingRequest req(bridge_->lastOutgoingRequest(tid)); | |
| bool exc = (flags1 & 0x20) != 0; // bit 5: EXCEPTION | |
| BinaryAny ret; | |
| std::vector< BinaryAny > outArgs; | |
| if (exc) { | |
| ret = unmarshal.readValue( | |
| css::uno::TypeDescription(cppu::UnoType< css::uno::Any >::get())); | |
| if (!typelib_typedescription_isAssignableFrom( | |
| (css::uno::TypeDescription( | |
| cppu::UnoType< css::uno::RuntimeException >::get()). | |
| get()), | |
| ret.getType().get())) | |
| { | |
| sal_Int32 n = 0; | |
| typelib_TypeDescriptionReference ** p = 0; | |
| switch (req.member.get()->eTypeClass) { | |
| case typelib_TypeClass_INTERFACE_ATTRIBUTE: | |
| { | |
| typelib_InterfaceAttributeTypeDescription * atd = | |
| reinterpret_cast< | |
| typelib_InterfaceAttributeTypeDescription * >( | |
| req.member.get()); | |
| n = req.setter ? atd->nSetExceptions : atd->nGetExceptions; | |
| p = req.setter | |
| ? atd->ppSetExceptions : atd->ppGetExceptions; | |
| break; | |
| } | |
| case typelib_TypeClass_INTERFACE_METHOD: | |
| { | |
| typelib_InterfaceMethodTypeDescription * mtd = | |
| reinterpret_cast< | |
| typelib_InterfaceMethodTypeDescription * >( | |
| req.member.get()); | |
| n = mtd->nExceptions; | |
| p = mtd->ppExceptions; | |
| break; | |
| } | |
| default: | |
| OSL_ASSERT(false); // this cannot happen | |
| break; | |
| } | |
| bool ok = false; | |
| for (sal_Int32 i = 0; i != n; ++i) { | |
| if (typelib_typedescriptionreference_isAssignableFrom( | |
| p[i], | |
| reinterpret_cast< typelib_TypeDescriptionReference * >( | |
| ret.getType().get()))) | |
| { | |
| ok = true; | |
| break; | |
| } | |
| } | |
| if (!ok) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: reply message with bad exception type" | |
| " received")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| } else { | |
| switch (req.member.get()->eTypeClass) { | |
| case typelib_TypeClass_INTERFACE_ATTRIBUTE: | |
| if (!req.setter) { | |
| ret = unmarshal.readValue( | |
| css::uno::TypeDescription( | |
| reinterpret_cast< | |
| typelib_InterfaceAttributeTypeDescription * >( | |
| req.member.get())-> | |
| pAttributeTypeRef)); | |
| } | |
| break; | |
| case typelib_TypeClass_INTERFACE_METHOD: | |
| { | |
| typelib_InterfaceMethodTypeDescription * mtd = | |
| reinterpret_cast< | |
| typelib_InterfaceMethodTypeDescription * >( | |
| req.member.get()); | |
| ret = unmarshal.readValue( | |
| css::uno::TypeDescription(mtd->pReturnTypeRef)); | |
| for (sal_Int32 i = 0; i != mtd->nParams; ++i) { | |
| if (mtd->pParams[i].bOut) { | |
| outArgs.push_back( | |
| unmarshal.readValue( | |
| css::uno::TypeDescription( | |
| mtd->pParams[i].pTypeRef))); | |
| } | |
| } | |
| break; | |
| } | |
| default: | |
| OSL_ASSERT(false); // this cannot happen | |
| break; | |
| } | |
| } | |
| switch (req.kind) { | |
| case OutgoingRequest::KIND_NORMAL: | |
| { | |
| std::unique_ptr< IncomingReply > resp( | |
| new IncomingReply(exc, ret, outArgs)); | |
| uno_threadpool_putJob( | |
| bridge_->getThreadPool(), tid.getHandle(), resp.get(), 0, | |
| false); | |
| resp.release(); | |
| break; | |
| } | |
| case OutgoingRequest::KIND_REQUEST_CHANGE: | |
| OSL_ASSERT(outArgs.empty()); | |
| bridge_->handleRequestChangeReply(exc, ret); | |
| break; | |
| case OutgoingRequest::KIND_COMMIT_CHANGE: | |
| OSL_ASSERT(outArgs.empty()); | |
| bridge_->handleCommitChangeReply(exc, ret); | |
| break; | |
| default: | |
| OSL_ASSERT(false); // this cannot happen | |
| break; | |
| } | |
| } | |
| rtl::ByteSequence Reader::getTid(Unmarshal & unmarshal, bool newTid) const { | |
| if (newTid) { | |
| return unmarshal.readTid(); | |
| } | |
| if (lastTid_.getLength() == 0) { | |
| throw css::uno::RuntimeException( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "URP: message with NEWTID received when last TID has not" | |
| " yet been set")), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| return lastTid_; | |
| } | |
| } |