void OTMessageOutbuffer::AddSentMessage(OTMessage & theMessage) // must be heap allocated. { int64_t lRequestNum = 0; if (theMessage.m_strRequestNum.Exists()) lRequestNum = atol(theMessage.m_strRequestNum.Get()); // The map index is the request number on the message itself. // ---------------- // It's technically possible to have TWO messages (from two different // servers) that happen to have the same request number. So we verify // that here, before removing any old ones with the same number and IDs. // mapOfMessages::iterator it = m_mapMessages.begin(); for (; it != m_mapMessages.end(); ++it) { // ----------------------------- const int64_t & lTempReqNum = it->first; // ----------------------- if (lTempReqNum != lRequestNum) { continue; } // ----------------------- OTMessage * pMsg = it->second; OT_ASSERT(NULL != pMsg); // ----------------------------- // // If a server ID was passed in, but doesn't match the server ID on this message, // Then skip this one. (Same with the NymID.) // if (!theMessage.m_strServerID.Compare(pMsg->m_strServerID) || !theMessage.m_strNymID. Compare(pMsg->m_strNymID)) { continue; } // -------- else { delete pMsg; pMsg = NULL; m_mapMessages.erase(it); break; } } // Whatever it was, it's gone now! // ---------------------------------- // Now that we KNOW there's nothing already there with that request number (for that // server ID and Nym ID), we go ahead and add the new message to the map. (And take ownership.) // m_mapMessages.insert(std::pair<int64_t, OTMessage *>(lRequestNum, &theMessage)); // ---------------------------------- // // Save it to local storage, in case we don't see the reply until the next run. // bool bAlreadyExists=false, bIsNewFolder=false; OTString strFolder, strFolder1, strFolder2; strFolder1.Format("%s%s%s", OTFolders::Nym().Get(), OTLog::PathSeparator(), theMessage.m_strServerID.Get()); strFolder2.Format("%s%s%s", strFolder1.Get(), OTLog::PathSeparator(), "sent" /*todo hardcoding*/); // ---------------------------------- strFolder.Format("%s%s%s", strFolder2.Get(), OTLog::PathSeparator(), theMessage.m_strNymID.Get()); // ---------------------------------- OTString strFolderPath = "", strFolder1Path = "", strFolder2Path = ""; OTPaths::AppendFolder(strFolderPath, m_strDataFolder,strFolder ); OTPaths::AppendFolder(strFolder1Path, m_strDataFolder,strFolder1); OTPaths::AppendFolder(strFolder2Path, m_strDataFolder,strFolder2); OTPaths::ConfirmCreateFolder(strFolderPath,bAlreadyExists,bIsNewFolder); OTPaths::ConfirmCreateFolder(strFolder1Path,bAlreadyExists,bIsNewFolder); OTPaths::ConfirmCreateFolder(strFolder2Path,bAlreadyExists,bIsNewFolder); OTString strFile; strFile.Format("%s.msg", theMessage.m_strRequestNum.Get()); theMessage.SaveContract(strFolder.Get(), strFile.Get()); // ---------------------------------- // We also keep a list of the request numbers, so let's load it up, add the number // to that list, and then save it again. // OTNumList theNumList; std::string str_data_filename("sent.dat"); // todo hardcoding. if (OTDB::Exists(strFolder.Get(), str_data_filename)) { OTString strNumList(OTDB::QueryPlainString(strFolder.Get(), str_data_filename)); if (strNumList.Exists()) theNumList.Add(strNumList); theNumList.Add(lRequestNum); // Add the new request number to it. } else // it doesn't exist on disk, so let's just create it from the list we have in RAM so we can store it to disk. { it = m_mapMessages.begin(); while (it != m_mapMessages.end()) { // ----------------------------- const int64_t & lTempReqNum = it->first; // ----------------------- OTMessage * pMsg = it->second; OT_ASSERT(NULL != pMsg); // ----------------------------- // // If a server ID was passed in, but doesn't match the server ID on this message, // Then skip this one. (Same with the NymID.) // if (!theMessage.m_strServerID.Compare(pMsg->m_strServerID) || !theMessage.m_strNymID. Compare(pMsg->m_strNymID)) { ++it; continue; } // -------- else { theNumList.Add(lTempReqNum); } ++it; } }// else // ---------------------------------- // By this point, theNumList has either been loaded from local storage and had the new number added, // or it wasn't in local storage and thus we created it and added all the numnbers to it (including new one.) // Therefore nothing left to do here, but save it back again! // OTString strOutput; theNumList.Output(strOutput); if (!OTDB::StorePlainString(strOutput.Get(), strFolder.Get(), str_data_filename)) // todo hardcoding. { OTLog::Error("OTMessageOutbuffer::AddSentMessage: Error: failed writing list of request numbers to storage.\n"); } }
// Process my reply back out to the client. @something. void OTClientConnection::ProcessReply(OTMessage &theReply) { int err; uint32_t nwritten; bool bSendCommand = false; bool bSendPayload = false; u_header theCMD; OTPayload thePayload; // For now let's send ALL replies in Envelopes (encrypted to public key of client) // IF we have a public key, that is. Otherwise we send as a normal message. // // All messages already require either a public key, or a nymID used to look up a // public key. So given that I have that information when I reply, I might as well // ENCRYPT my reply to that same public key. More secure that way. // // The wallet (and server) are both ready to open and process these encrypted envelopes. // If GetKey() returns something, that means the key was set in there, it's // not just a null pointer. This means we can use it! So let's encrypt to it. if (m_PublicKey.GetKey()) { OTString strEnvelopeContents; // Save the ready-to-go message into a string. theReply.SaveContract(strEnvelopeContents); OTEnvelope theEnvelope; // Seal the string up into an encrypted Envelope theEnvelope.Seal(m_PublicKey, strEnvelopeContents); // From here on out, theMessage is disposable. OTPayload takes over. // OTMessage doesn't care about checksums and headers. thePayload.SetEnvelope(theEnvelope); // Now that the payload is ready, we'll set up the header. SetupHeader(&theCMD, CMD_TYPE_1, TYPE_1_CMD_2, thePayload); } else { thePayload.SetMessage(theReply); // Now that the payload is ready, we'll set up the header. SetupHeader(&theCMD, CMD_TYPE_1, TYPE_1_CMD_1, thePayload); } bSendCommand = true; bSendPayload = true; fprintf(stderr, "\n****************************************************************\n" "===> Finished setting up header for response.\nFirst 9 bytes are: %d %d %d %d %d %d %d %d %d...\n", theCMD.buf[0], theCMD.buf[1], theCMD.buf[2], theCMD.buf[3], theCMD.buf[4], theCMD.buf[5], theCMD.buf[6], theCMD.buf[7], theCMD.buf[8]); // ------------------------------------------------------------------------------ /* // Write to Client strcpy(buffer, "Hello Client!"); SFSocketWrite(clientSocket, buffer, strlen(buffer)); */ if (bSendCommand) { int nHeaderSize = OT_CMD_HEADER_SIZE; for (nwritten = 0; nwritten < nHeaderSize; nwritten += err) { err = SFSocketWrite(m_pSocket, theCMD.buf + nwritten, nHeaderSize - nwritten); #ifdef _WIN32 if (0 == err || SOCKET_ERROR == err) // 0 means disconnect. error means error. >0 means bytes read. #else if (err <= 0) #endif break; } } // At this point, we have sent the header across the pipe. if (bSendPayload) { uint32_t nPayloadSize = thePayload.GetSize(); for (nwritten = 0; nwritten < nPayloadSize; nwritten += err) { err = SFSocketWrite(m_pSocket, (unsigned char *)thePayload.GetPayloadPointer() + nwritten, nPayloadSize - nwritten); #ifdef _WIN32 if (0 == err || SOCKET_ERROR == err) // 0 means disconnect. error means error. >0 means bytes read. #else if (err <= 0) #endif break; } } // At this point, we have sent the payload across the pipe. fprintf(stderr, "...Done.\n"); }