void MetaEntry::handleRealGotMessage (QObject *msgObj) { IMessage *msg = qobject_cast<IMessage*> (msgObj); if (!msg) { qWarning () << Q_FUNC_INFO << msgObj << "doesn't implement IMessage"; return; } MetaMessage *message = new MetaMessage (msgObj, this); const bool shouldSort = !Messages_.isEmpty () && Messages_.last ()->GetDateTime () > msg->GetDateTime (); Messages_ << message; if (shouldSort) std::stable_sort (Messages_.begin (), Messages_.end (), [] (IMessage *left, IMessage *right) { return left->GetDateTime () < right->GetDateTime (); }); emit gotMessage (message); }
void UnreadQueueManager::AddMessage (QObject *msgObj) { IMessage *msg = qobject_cast<IMessage*> (msgObj); QObject *entryObj = msg->ParentCLEntry (); if (!Queue_.contains (entryObj)) Queue_ << entryObj; }
void Packet::serialize(IMessage& message, ByteArray& buffer) { BinaryWriter writer(buffer); BinaryWriter messageWriter(_data); message.serialize(messageWriter); _id = message.getId(); _length = static_cast<uint>(_data.size()); _lengthType = computeLengthType(_length); _header = computeHeader(_id, _lengthType); if (_header == 0) { throw std::logic_error("header must be non null"); } writer.writeShort(_header); switch (_lengthType) { case 1: writer.writeByte(static_cast<char>(_length)); break; case 2: writer.writeUShort(static_cast<ushort>(_length)); break; case 3: // TODO: Write for 3 bytes length break; default: break; } writer.writeBytes(_data, false); }
IMessage* SSLSession::CreateRequest() { IMessage* req = NULL; switch (msgType) { case MSG_TYPE_TCP_OLD: req = new TcpMessageOld(); break; case MSG_TYPE_SSL_PB: req = new SslMessagePB(); break; case MSG_TYPE_TCP_NEW: req = new CustomMessage(MSG_TYPE_TCP_NEW); break; case MSG_TYPE_SSL_NEW: req = new CustomMessage(MSG_TYPE_SSL_NEW); break; } req->SetSslSession(shared_from_this()); return req; /* ssl_session_ptr sess = shared_from_this(); ssl_request_ptr req = boost::factory<ssl_request_ptr>()(sess); return req; */ }
IMessage* SSLSession::create_request() { IMessage* req = NULL; switch (m_msgType) { case MSG_TYPE_HTTP: req = new http_message(); break; case MSG_TYPE_TCP_OLD: req = new tcp_message_old(); break; case MSG_TYPE_SSL_PB: req = new ssl_message(); break; case MSG_TYPE_TCP_NEW: req = new CustomMessage(MSG_TYPE_TCP_NEW); break; case MSG_TYPE_SSL_NEW: req = new CustomMessage(MSG_TYPE_SSL_NEW); break; } req->SetSslSession(shared_from_this()); return req; /* ssl_session_ptr sess = shared_from_this(); ssl_request_ptr req = boost::factory<ssl_request_ptr>()(sess); return req; */ }
IMessage *CmReponseHander::GetQueryRspByResult(int result) { CM_TRACE_DEBUG(gettext("Handle message return. result=") << result); IMessage *pRsp = IMessageFactory::CreateMessage("ubp.cm." + msgType_ + "List"); const Descriptor *descriptor = pRsp->GetDescriptor(); const Reflection *reflection = pRsp->GetReflection(); const FieldDescriptor *field = descriptor->FindFieldByName("result"); reflection->SetInt32(pRsp, field, result); return pRsp; }
//------------------------------------------------------------------------ tresult Plug::sendTextMessage (const char16* text) { IMessage* message = allocateMessage (); if (!message) return kResultFalse; FReleaser msgReleaser (message); message->setMessageID ("TextMessage"); message->getAttributes ()->setString ("Text", text); return sendMessage (message); }
//------------------------------------------------------------------------ tresult ComponentBase::sendTextMessage (const char8* text) { IMessage* message = allocateMessage (); if (!message) return kResultFalse; FReleaser msgReleaser (message); message->setMessageID ("TextMessage"); message->getAttributes ()->setString ("Text", STR (text)); return sendMessage (message); }
// 读请求 void SSLSession::read() { IMessage* req = create_request(); boost::asio::async_read(socket_, boost::asio::buffer(req->GetMsgHeader(), req->GetMsgHeaderSize()), boost::asio::transfer_all(), strand_.wrap( boost::bind(&SSLSession::handle_read_head, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, req) ) ); }
void amqp::Sender::_addAnnotationsToMessage(pn_message_t *pnmessage, IMessage const &message) { pn_data_t *pnmessage_annotations = pn_message_annotations(pnmessage); pn_data_put_map(pnmessage_annotations); pn_data_enter(pnmessage_annotations); MessageMeta::const_iterator i = message.getAnnotations().begin(); for (; i != message.getAnnotations().end(); ++i) { _serializeMessageMeta(pnmessage_annotations, (*i)); } pn_data_exit(pnmessage_annotations); }
void Plugin::handleMetadata () { QNetworkReply *reply = qobject_cast<QNetworkReply*> (sender ()); if (!reply) { qWarning () << Q_FUNC_INFO << "sender is not a QNetworkReply:" << sender (); return; } const QString& pasteUrl = reply->header (QNetworkRequest::LocationHeader).toString (); QPointer<QObject> entryObj = Reply2Entry_ [reply]; if (!entryObj) { QApplication::clipboard ()->setText (pasteUrl, QClipboard::Clipboard); QApplication::clipboard ()->setText (pasteUrl, QClipboard::Selection); const Entity& e = Util::MakeNotification (tr ("Text pasted"), tr ("Your text has been pasted: %1. The URL has " "been copied to the clipboard."), PInfo_); emit gotEntity (e); return; } ICLEntry *entry = qobject_cast<ICLEntry*> (entryObj); if (!entry) { qWarning () << Q_FUNC_INFO << "unable to cast" << entryObj << "to ICLEntry"; return; } IMessage::MessageType type = entry->GetEntryType () == ICLEntry::ETMUC ? IMessage::MTMUCMessage : IMessage::MTChatMessage; QObject *msgObj = entry->CreateMessage (type, QString (), pasteUrl); IMessage *msg = qobject_cast<IMessage*> (msgObj); if (!msg) { qWarning () << Q_FUNC_INFO << "unable to cast" << msgObj << "to IMessage"; return; } msg->Send (); }
void Plugin::hookFormatBodyEnd (IHookProxy_ptr proxy, QObject *chatTab, QString body, QObject *msgObj) { IMessage *msg = qobject_cast<IMessage*> (msgObj); if (msg->GetDirection () != IMessage::DIn || msg->GetMessageType () != IMessage::MTChatMessage) return; ICLEntry *other = qobject_cast<ICLEntry*> (msg->OtherPart ()); if (!other->GetEntryID ().contains ("*****@*****.**")) return; proxy->SetValue ("body", FormatBody (body)); }
void Sender::startSending() { std::thread SendThread( [&]() { do { try { IMessage *msg = sendQ.deQ(); /*Message* msg = dynamic_cast<Message*>(imsg); map<string, string> header = msg->getHeader();*/ if (msg->getCommand() == "send_stop") break; else if (msg->getCommand() == "file_upload") { if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort()))) { if (sendFile(msg)) { } } else Verbose::show("Connection failed!\n"); } else if (msg->getCommand() == "ack") { if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort()))) sendHeader(msg); } else { if (connectToPeer(msg->getRecvIP(), stoi(msg->getRecvPort()))) { sendHeader(msg); sendBody(msg); } } } catch (exception ex) { string s = ex.what(); Verbose::show("\n In send Thread: " + s); } } while (1); } ); SendThread.detach(); }
// 读请求 void SSLSession::read() { IMessage* req = CreateRequest(); int size = req->GetMsgHeaderSize(); boost::asio::async_read(shared_from_this()->socket, boost::asio::buffer(req->GetMsgHeader(), req->GetMsgHeaderSize()), boost::asio::transfer_all(), strand.wrap( boost::bind(&SSLSession::OnReadHead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, req) ) ); }
void TrackSearchLayout::ProcessMessage(IMessage &message) { int type = message.Type(); if (type == message::RequeryTrackList) { this->Requery(); } }
void Plugin::hookMessageCreated (IHookProxy_ptr proxy, QObject*, QObject *msgObj) { if (ConvScriptPath_.isEmpty ()) return; if (!XmlSettingsManager::Instance () .property ("SubstituteOutgoing").toBool ()) return; if (HandledObjects_.contains (msgObj)) return; IMessage *msg = qobject_cast<IMessage*> (msgObj); if (!msg) { qWarning () << Q_FUNC_INFO << "message" << msgObj << "doesn't implement IMessage"; return; } IRichTextMessage *richMsg = qobject_cast<IRichTextMessage*> (msgObj); if (!richMsg) return; QString body = richMsg->GetRichBody (); if (body.isEmpty ()) body = msg->GetBody (); if (!body.contains ("$$")) return; const QString newBody = HandleBody (body); if (newBody == body) return; if (XmlSettingsManager::Instance () .property ("WarnInOutgoing").toBool ()) msg->SetBody (msg->GetBody () + " (this message contains " "inline formulas, enable XHTML-IM to view them)"); richMsg->SetRichBody (newBody); HandledObjects_ << msgObj; }
//----------------------------------------------------------------------------- void HostCheckerProcessor::sendLogEventMessage (const LogEvent& logEvent) { IMessage* message = allocateMessage (); FReleaser msgReleaser (message); if (message) { message->setMessageID ("LogEvent"); IAttributeList* attributes = message->getAttributes (); if (attributes) { ASSERT (logEvent.id >= 0); attributes->setInt ("ID", logEvent.id); attributes->setInt ("Count", logEvent.count); sendMessage (message); } } }
//----------------------------------------------------------------------------- tresult PLUGIN_API HostCheckerController::connect (IConnectionPoint* other) { Steinberg::tresult tResult = ComponentBase::connect (other); if (peerConnection) { for (Steinberg::int32 paramIdx = 0; paramIdx < getParameterCount (); ++paramIdx) { Steinberg::Vst::ParameterInfo paramInfo = {0}; if (getParameterInfo (paramIdx, paramInfo) == Steinberg::kResultOk) { IMessage* newMsg = allocateMessage (); if (newMsg) { newMsg->setMessageID ("Parameter"); Steinberg::Vst::IAttributeList* attr = newMsg->getAttributes (); if (attr) { attr->setInt ("ID", paramInfo.id); } sendMessage (newMsg); } } } FUnknownPtr<IAudioProcessor> proc (other); if (proc) { OPtr<IMessage> newMsg = allocateMessage (); if (newMsg) { newMsg->setMessageID ("LogEvent"); Steinberg::Vst::IAttributeList* attr = newMsg->getAttributes (); if (attr) { attr->setInt ("ID", kLogIdProcessorControllerConnection); attr->setInt ("Count", 1); } notify (newMsg); } } } return tResult; }
IMessage* ClientHandler::receiveHeader(Socket& socket_) { vector<string> received; while (true) { string command = socket_.recvString('\n'); // interpret test command if (command == "\n" || command.size() == 0) { command = socket_.recvString('\n'); break; //header received } received.push_back(command); } IMessage *msg = new Message(); msg->parseMessage(received); return msg; }
void ServerDaemonImpl::flushMessage() { if (m_HomeConnection == NULL) { return; } while (m_MessageQueue->Size() > 0) { IMessage * msg = m_MessageQueue->Front(); std::string _msg = msg->GetMessage(); delete msg; m_MessageQueue->Pop(); if (m_HomeConnection->IsConnected()) { Log("notify home -> %s", _msg.c_str()); m_HomeConnection->WriteData(_msg); } else { Log("notify home failed, reason: socket closed."); } } }
std::string MessageDispatchedEvent::createDetail(IMessage& message) { auto detail = std::string("Command Content:"); for (auto& c : message.getCommand().content) { detail += std::string(" "); detail += std::to_string((unsigned int)c); } return detail; }
IMessage* MessagePasserImpl::Retrieve() { // (It should be fairly easy to use a more efficient thread-safe queue, // since there's only one thread adding items and one thread consuming; // but it's not worthwhile yet.) IMessage* msg = NULL; { CScopeLock lock(m_Mutex); if (! m_Queue.empty()) { msg = m_Queue.front(); m_Queue.pop(); } } if (m_Trace && msg) debug_printf("%8.3f retrieved message: %s\n", timer_Time(), msg->GetName()); return msg; }
void amqp::Sender::send(IMessage const &message, Address const &address) { pn_data_t *pnmessage_body = NULL; pn_message_t *pnmessage = pn_message(); if (pnmessage == NULL) { throw std::exception("ERROR: Message could not be created."); } pn_message_set_address(pnmessage, address.toString().c_str()); _addMetaToMessage(pnmessage, message); pnmessage_body = pn_message_body(pnmessage); pn_data_put_binary(pnmessage_body, pn_bytes(message.getSize(), message.getBytes())); pn_messenger_put(m_messenger, pnmessage); if (isError()) { _throwError(); } // To avoid traffic flud and speed up the solution better to use blocking scokets in tracking mode if (isTraking()) { Log("Sending messages to %s\n", address.toString().c_str()); m_tracker = pn_messenger_outgoing_tracker(m_messenger); pn_messenger_send(m_messenger, -1); // sync } else { pn_messenger_send(m_messenger, 1); // async } if (isError()) { _throwError(); } _checkTracking(); pn_message_free(pnmessage); }
void Plugin::hookFormatBodyEnd (IHookProxy_ptr proxy, QObject*, QString body, QObject *msgObj) { IMessage *msg = qobject_cast<IMessage*> (msgObj); if (msg->GetDirection () != IMessage::DIn || msg->GetMessageType () != IMessage::MTChatMessage) return; ICLEntry *other = qobject_cast<ICLEntry*> (msg->OtherPart ()); if (!other) { qWarning () << Q_FUNC_INFO << "NULL other part for message" << msgObj << msg->GetBody (); return; } if (!other->GetEntryID ().contains ("*****@*****.**")) return; proxy->SetValue ("body", FormatBody (body)); }
bool Plugin::ShouldHandle (QObject* msgObj, IMessage::Direction direction, IMessage::Type type) { IMessage *msg = qobject_cast<IMessage*> (msgObj); if (!msg) { qWarning () << Q_FUNC_INFO << "unable to cast" << msgObj << "to IMessage"; return false; } if (msg->GetDirection () != direction || msg->GetMessageType () != type) { return false; } ICLEntry *other = qobject_cast<ICLEntry*> (msg->OtherPart ()); if (!other) { qWarning () << Q_FUNC_INFO << "unable to cast" << msg->OtherPart () << "to ICLEntry"; return false; } if (!other->GetEntryID ().contains ("*****@*****.**")) return false; return true; }
void amqp::Sender::_addMetaToMessage(pn_message_t *pnmessage, IMessage const &message) { pn_timestamp_t utcTime; time(&utcTime); _addPropertiesToMessage(pnmessage, message); _addAnnotationsToMessage(pnmessage, message); pn_message_set_content_type(pnmessage, message.getContentType().c_str()); pn_message_set_inferred(pnmessage, true); pn_message_set_subject(pnmessage, message.getSubject().c_str()); pn_message_set_ttl(pnmessage, 86400000); pn_message_set_creation_time(pnmessage, utcTime); switch (message.getEncoding()) { case IMessage::UTF8: pn_message_set_content_encoding(pnmessage, "UTF-8"); break; case IMessage::UTF16: pn_message_set_content_encoding(pnmessage, "UTF-16"); break; } }
void ClientHandler::operator()(Socket& socket_) { try { IMessage *msg = receiveHeader(socket_); if (msg->getCommand() == "send_string") Verbose::show("\nString received: " + msg->getValue() + "\n"); else if (msg->getCommand() == "file_upload") { using HighResolutionClock = chrono::high_resolution_clock; HighResolutionClock::time_point t1 = HighResolutionClock::now(); if (acceptFile(msg, socket_)) { } else Verbose::show("\nFile Upload Failed!\n"); HighResolutionClock::time_point t2 = HighResolutionClock::now(); auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count(); msg->setTime(to_string(duration)); } else if (msg->getCommand() == "ack") { string s = "\n Reply from " + msg->getSendIP() + msg->getSendPort(); s += ": " + msg->getValue() + " uploaded successfully!\n"; Verbose::show(s); } else //(msg->getCommand() == "ack_get_dir") { receiveBody(socket_,msg); } recvr->postMessage(msg); } catch (std::exception& ex) { Verbose::show(" Exception caught:", always); Verbose::show(std::string("\n ") + ex.what() + "\n\n"); } socket_.shutDown(); socket_.close(); }
void Plugin::hookGotMessage (LeechCraft::IHookProxy_ptr proxy, QObject *message) { IMessage *msg = qobject_cast<IMessage*> (message); if (!msg) return; if (msg->GetMessageType () != IMessage::MTChatMessage && msg->GetMessageType () != IMessage::MTMUCMessage) return; if ((msg->GetMessageType () == IMessage::MTChatMessage && !XmlSettingsManager::Instance ().property ("EnableForChats").toBool ()) || (msg->GetMessageType () == IMessage::MTMUCMessage && !XmlSettingsManager::Instance ().property ("EnableForMUCs").toBool ())) return; QString str = msg->GetBody (); if (str.length () < 3) return; int caps = 0; int alphaLength = 0; for (int i = 0, size = str.length (); i < size; ++i) { if (!str.at (i).isLetter ()) continue; ++alphaLength; if (str.at (i).isUpper ()) ++caps; } double ratio = static_cast<double> (XmlSettingsManager::Instance () .property ("CapsPercentage").toInt ()) / 100; if (alphaLength > 3 && static_cast<double> (caps) / alphaLength < ratio) return; for (int i = 0, size = str.length (); i < size; ++i) str [i] = str.at (i).toLower (); msg->SetBody (str); }
STDMETHODIMP CExtImpl::OnWriteComplete(IExchExtCallback* pecb, ULONG ulFlags) { if (_context != EECONTEXT_SENDNOTEMESSAGE) return S_FALSE; if (ulFlags == EEME_COMPLETE_FAILED) // Nothing to unwind return S_FALSE; if (!_fInSubmitState) // This is not a submission. return S_FALSE; if (_bEncrypt || _bSign) { IMessage *pmsg = 0; RECIPIENTDIALOGSTRUCT *prds; PGPOptionListRef signOptions = NULL; HWND hwnd; PGPError nError = kPGPError_NoErr; pecb->GetWindow(&hwnd); if (!hwnd) hwnd = GetTopWindow(NULL); CWaitCursor wait; // Mark busy HRESULT hr = pecb->GetObject(NULL, (IMAPIProp**)&pmsg); if (FAILED(hr)) { UIDisplayStringID(hwnd, IDS_E_NOMESSAGE); return E_ABORT; } prds = (RECIPIENTDIALOGSTRUCT *) calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1); nError = PGPsdkLoadDefaultPrefs(_pgpContext); if (IsPGPError(nError)) { UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError); return E_ABORT; } nError = PGPOpenDefaultKeyRings(_pgpContext, (PGPKeyRingOpenFlags)0, &(prds->OriginalKeySetRef)); if (IsPGPError(nError)) { UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError); return E_ABORT; } if (_bEncrypt) nError = GetRecipients(pecb, _pgpContext, _tlsContext, prds); if (IsPGPError(nError)) { if (nError != kPGPError_UserAbort) UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError); return E_ABORT; } nError = EncryptSignMessage(hwnd, pmsg, prds, &signOptions); if (signOptions != NULL) { PGPFreeOptionList(signOptions); signOptions = NULL; } FreeRecipients(prds); if (NULL!=(int)(prds->OriginalKeySetRef)) { PGPFreeKeySet(prds->OriginalKeySetRef); prds->OriginalKeySetRef = NULL; } free(prds); pmsg->Release(); if (IsPGPError(nError)) return E_ABORT; } return S_FALSE; }
STDMETHODIMP CExtImpl::OnRead(IExchExtCallback* peecb) { HWND hwnd; peecb->GetWindow(&hwnd); if (!hwnd) hwnd = GetTopWindow(NULL); switch (_context) { case EECONTEXT_SENDNOTEMESSAGE: { BOOL fAddButtons = TRUE; int nNumButtons; int nIndex; TBBUTTON tbbNew[5]; TBBUTTON tbbCheck; // Check to make sure the buttons aren't already on the toolbar nNumButtons = SendMessage(_hwndSendToolbar, TB_BUTTONCOUNT, 0, 0); for (nIndex=0; nIndex<nNumButtons; nIndex++) { SendMessage(_hwndSendToolbar, TB_GETBUTTON, (WPARAM) nIndex, (LPARAM) &tbbCheck); // If a button exists with the same bitmap ID and command ID // as the Encrypt button, odds are good that the button is // already on the toolbar if ((tbbCheck.iBitmap == (int)_itbmEncrypt) && (tbbCheck.idCommand == (int)_cmdidEncrypt)) { fAddButtons = FALSE; nIndex = nNumButtons; } } if (fAddButtons) { tbbNew[0].iBitmap = 0; tbbNew[0].idCommand = 0; tbbNew[0].fsState = 0; tbbNew[0].fsStyle = TBSTYLE_SEP; tbbNew[0].dwData = 0; tbbNew[0].iString = -1; tbbNew[1].iBitmap = _itbmEncrypt; tbbNew[1].idCommand = _cmdidEncrypt; tbbNew[1].fsState = TBSTATE_ENABLED; tbbNew[1].fsStyle = TBSTYLE_CHECK; tbbNew[1].dwData = 0; tbbNew[1].iString = -1; tbbNew[2].iBitmap = _itbmSign; tbbNew[2].idCommand = _cmdidSign; tbbNew[2].fsState = TBSTATE_ENABLED; tbbNew[2].fsStyle = TBSTYLE_CHECK; tbbNew[2].dwData = 0; tbbNew[2].iString = -1; tbbNew[3].iBitmap = 0; tbbNew[3].idCommand = 0; tbbNew[3].fsState = 0; tbbNew[3].fsStyle = TBSTYLE_SEP; tbbNew[3].dwData = 0; tbbNew[3].iString = -1; tbbNew[4].iBitmap = _itbmPgpKeys; tbbNew[4].idCommand = _cmdidPgpKeys; tbbNew[4].fsState = TBSTATE_ENABLED; tbbNew[4].fsStyle = TBSTYLE_BUTTON; tbbNew[4].dwData = 0; tbbNew[4].iString = -1; SendMessage(_hwndSendToolbar, TB_ADDBUTTONS, 5, (LPARAM) tbbNew); } } break; case EECONTEXT_SENDPOSTMESSAGE: break; case EECONTEXT_READNOTEMESSAGE: { BOOL fAddButtons = TRUE; int nNumButtons; int nIndex; TBBUTTON tbbNew[5]; TBBUTTON tbbCheck; BOOL FYEO; // Check to make sure the buttons aren't already on the toolbar nNumButtons = SendMessage(_hwndReadToolbar, TB_BUTTONCOUNT, 0, 0); for (nIndex=0; nIndex<nNumButtons; nIndex++) { SendMessage(_hwndReadToolbar, TB_GETBUTTON, (WPARAM) nIndex, (LPARAM) &tbbCheck); // If a button exists with the same bitmap ID and command ID // as the Decrypt button, odds are good that the button is // already on the toolbar if ((tbbCheck.iBitmap == (int)_itbmDecrypt) && (tbbCheck.idCommand == (int)_cmdidDecrypt)) { fAddButtons = FALSE; nIndex = nNumButtons; } } if (fAddButtons) { tbbNew[0].iBitmap = 0; tbbNew[0].idCommand = 0; tbbNew[0].fsState = 0; tbbNew[0].fsStyle = TBSTYLE_SEP; tbbNew[0].dwData = 0; tbbNew[0].iString = -1; tbbNew[1].iBitmap = _itbmDecrypt; tbbNew[1].idCommand = _cmdidDecrypt; tbbNew[1].fsState = TBSTATE_ENABLED; tbbNew[1].fsStyle = TBSTYLE_BUTTON; tbbNew[1].dwData = 0; tbbNew[1].iString = -1; tbbNew[2].iBitmap = 0; tbbNew[2].idCommand = 0; tbbNew[2].fsState = 0; tbbNew[2].fsStyle = TBSTYLE_SEP; tbbNew[2].dwData = 0; tbbNew[2].iString = -1; tbbNew[3].iBitmap = _itbmPgpKeys; tbbNew[3].idCommand = _cmdidPgpKeys; tbbNew[3].fsState = TBSTATE_ENABLED; tbbNew[3].fsStyle = TBSTYLE_BUTTON; tbbNew[3].dwData = 0; tbbNew[3].iString = -1; SendMessage(_hwndReadToolbar, TB_ADDBUTTONS, 4, (LPARAM) tbbNew); } IMAPISession* psess; HRESULT hr = peecb->GetSession(&psess, NULL); if (FAILED(hr)) { UIDisplayStringID(hwnd, IDS_E_NOSESSION); return S_FALSE; } if (AutoDecrypt(_memoryMgr)) { IMessage *pmsg = 0; STATSTG StreamStats; DWORD dwInSize; UINT nOutSize; char *pInput; char *pOutput = NULL; BOOL bGotHTML = FALSE; PGPError nError = kPGPError_NoErr; char szFile[256]; char szName[256]; UIGetString(szName, sizeof(szName), IDS_LOGNAME); UIGetString(szFile, sizeof(szFile), IDS_DLL); CWaitCursor wait; // Mark busy hr = peecb->GetObject(NULL, (IMAPIProp**)&pmsg); if (FAILED(hr)) { return S_FALSE; } IStream *pstrmBody = 0; hr = pmsg->OpenProperty(PR_BODY_HTML, &IID_IStream, STGM_READWRITE, MAPI_MODIFY, (IUnknown**)&pstrmBody); if (FAILED(hr)) { hr = pmsg->OpenProperty(PR_BODY, &IID_IStream, STGM_READWRITE, MAPI_MODIFY, (IUnknown**)&pstrmBody); } else bGotHTML = TRUE; if (FAILED(hr)) { pmsg->Release(); psess->Release(); return S_FALSE; } pstrmBody->Stat(&StreamStats, STATFLAG_NONAME); dwInSize = StreamStats.cbSize.LowPart; pInput = (char *) calloc(dwInSize+1, sizeof(char)); if (!pInput) { UIDisplayStringID(hwnd, IDS_E_NOMEMORY); pstrmBody->Release(); pmsg->Release(); psess->Release(); return S_FALSE; } pstrmBody->Read(pInput, dwInSize, &dwInSize); pInput[dwInSize] = 0; if (AutoDecrypt(_memoryMgr)) { nError = DecryptVerifyBuffer(UIGetInstance(), hwnd, _pgpContext, _tlsContext, szName, szFile, pInput, dwInSize, FALSE, (VOID ** )&pOutput, &nOutSize, &FYEO); if (IsntPGPError(nError) && (nOutSize > 0) && (pOutput != NULL)) { LARGE_INTEGER li = {0,0}; ULARGE_INTEGER uli = {nOutSize, 0}; BOOL fPartied; char *szBuffer = NULL; // Alter only the block of encrypted/signed text // if this is not HTML if((FYEO)||(GetSecureViewerPref(_pgpContext))) { TempestViewer((void *)_pgpContext,hwnd, pOutput,nOutSize,FYEO); } else { szBuffer = (char *) calloc(dwInSize+nOutSize+1, sizeof(char)); strcpy(szBuffer, pOutput); if (strlen(szBuffer) > 0) { uli.LowPart = strlen(szBuffer); pstrmBody->Seek(li, STREAM_SEEK_SET, NULL); pstrmBody->Write(szBuffer, strlen(szBuffer), NULL); pstrmBody->SetSize(uli); pstrmBody->Commit(STGC_DEFAULT); pstrmBody->Release(); RTFSync(pmsg, RTF_SYNC_BODY_CHANGED, &fPartied); } free(szBuffer); } PGPFreeData(pOutput); } else pstrmBody->Release(); } else pstrmBody->Release(); free(pInput); pmsg->Release(); } psess->Release(); } break; case EECONTEXT_READPOSTMESSAGE: break; default: // This way, the function defends itself against unknown future // variants, as FindREOnNote is less robust than it might be. return S_FALSE; } return S_FALSE; }