CMessage::CMessage( CMessage const & _message, CPubKey const & _prevKey, uint256 const & _actionKey, uint256 const & _id )
: m_header( (int)_message.m_header.m_payloadKind, std::vector<unsigned char>(), GetTime(), _prevKey, _actionKey, _id )
{
createPayload( _message, m_payload );
CommunicationProtocol::signPayload( m_payload, m_header.m_signedHash );
}
void JingleSessionImpl::sendTransportReplace(const JingleContentID& id, JingleTransportPayload::ref transPayload) {
JinglePayload::ref payload = createPayload();
JingleContentPayload::ref content = boost::make_shared<JingleContentPayload>();
content->setCreator(id.getCreator());
content->setName(id.getName());
content->addTransport(transPayload);
payload->setAction(JinglePayload::TransportReplace);
payload->addContent(content);
sendSetRequest(payload);
}
std::string JingleSessionImpl::sendTransportInfo(const JingleContentID& id, JingleTransportPayload::ref transPayload) {
JinglePayload::ref payload = createPayload();
JingleContentPayload::ref content = boost::make_shared<JingleContentPayload>();
content->setCreator(id.getCreator());
content->setName(id.getName());
content->addTransport(transPayload);
payload->setAction(JinglePayload::TransportInfo);
payload->addPayload(content);
return sendSetRequest(payload);
}
const std::string getAccessToken()
{
std::string encodedHeader = createHeader();
std::string encodedPayload = createPayload();
// trim '=' from end of encoded header
encodedHeader.erase(std::find_if(encodedHeader.rbegin(), encodedHeader.rend(),
[](char& ch)->bool {return ch != '='; }).base(), encodedHeader.end());
// trim '=' from end of encoded payload
encodedPayload.erase(std::find_if(encodedPayload.rbegin(), encodedPayload.rend(),
[](char& ch)->bool { return ch != '='; }).base(), encodedPayload.end());
Log::info("Encoded JWT header: " + encodedHeader);
Log::info("Encoded JWT payload: " + encodedPayload);
// Convert to a URL and filename safe variant:
// Replace '+' with '-' && '/' with '_'
std::replace(encodedHeader.begin(), encodedHeader.end(), '+','-');
std::replace(encodedHeader.begin(), encodedHeader.end(), '/','_');
std::replace(encodedPayload.begin(), encodedPayload.end(), '+','-');
std::replace(encodedPayload.begin(), encodedPayload.end(), '/','_');
std::string encodedBody = encodedHeader + "." + encodedPayload;
// sign the encoded body
_digestEngine.update(encodedBody.c_str(), static_cast<unsigned>(encodedBody.length()));
Poco::Crypto::DigestEngine::Digest digest = _digestEngine.signature();
// The signature generated contains CRLF line endings.
// Use a line ending converter to remove these CRLF
std::ostringstream ostr;
Poco::OutputLineEndingConverter lineEndingConv(ostr, "");
Poco::Base64Encoder encoder(lineEndingConv);
encoder << std::string(digest.begin(), digest.end());
encoder.close();
std::string encodedSig = ostr.str();
// trim '=' from end of encoded signature
encodedSig.erase(std::find_if(encodedSig.rbegin(), encodedSig.rend(),
[](char& ch)->bool { return ch != '='; }).base(), encodedSig.end());
// Be URL and filename safe
std::replace(encodedSig.begin(), encodedSig.end(), '+','-');
std::replace(encodedSig.begin(), encodedSig.end(), '/','_');
Log::info("Sig generated is : " + encodedSig);
const std::string jwtToken = encodedBody + "." + encodedSig;
Log::info("JWT token generated: " + jwtToken);
return jwtToken;
}
void JingleSessionImpl::sendTransportAccept(const JingleContentID& id, JingleTransportPayload::ref transPayload) {
JinglePayload::ref payload = createPayload();
JingleContentPayload::ref content = boost::make_shared<JingleContentPayload>();
content->setCreator(id.getCreator());
content->setName(id.getName());
content->addTransport(transPayload);
payload->setAction(JinglePayload::TransportAccept);
payload->addPayload(content);
// put into IQ:set and send it away
sendSetRequest(payload);
}
anbMessage unserializeMessage (char* msgBuffer)
{
anbMessage msg;
char *visitor = msgBuffer;
setTxID (&msg, (unsigned char) *visitor);
++visitor;
setRxID (&msg, (unsigned char) *visitor);
++visitor;
setType (&msg, (unsigned char) *visitor);
++visitor;
setSize (&msg, (unsigned char) *visitor);
if (getSize (&msg) != 0)
{
createPayload (&msg, getSize (&msg));
++visitor;
setPayload (&msg, visitor);
}
return msg;
}
/** ------------------------------------------------------------------------ **
* \brief Encode an ISF representation into ISF *
* *
* Given an ISF representation (the structure ISF_t which contains a list of *
* strokes, drawing attributes ...), create an ISF "file". *
* *
* \param pISF pointer on the ISF structure to encode *
* \param rootTag pointer where the root tag of the file is put. *
* \param transformList_ptr pointer on a list of transformation to apply *
* That list can be: *
* - empty : no transformation is applied *
* - have only one element : this transformation *
* is applied to every stroke. This one is *
* usefull if your strokes are using pixel *
* units. Just add a transformation matrix to *
* turn the coordinates into himetric. *
* - be as long as the stroke list : each *
* transformation matchs the respective stroke. *
* \param fullPayloadSize pointer on a int where the size of encoded file *
* is put. *
* *
* \returns the error code given while processing *
** ------------------------------------------------------------------------ **/
int createISF (
ISF_t * pISF,
payload_t ** rootTag,
transform_t * transformList_ptr,
INT64 * fullPayloadSize)
{
int err = OK;
drawAttrs_t ** ptrDA = &(pISF->drawAttrs),
* ptrDA_tmp;
INT64 payloadSize = 0;
payload_t * lastPayload_ptr = NULL;
err = createPayload(rootTag,
11,/* 11 B = 1 B (0x00) + 10 B (payload size) */
NULL);
if (err == OK)
{
lastPayload_ptr = *rootTag;
/* Drawing attributes */
/* First, remove useless drawing attributes structures */
while (*ptrDA)
{
if((*ptrDA)->nStrokes == 0)
{
/* delete it */
ptrDA_tmp = *ptrDA;
*ptrDA = (*ptrDA)->next;
free(ptrDA_tmp);
} else {
ptrDA = &((*ptrDA)->next);
}
}
if (pISF->drawAttrs)
{
err = createDrawAttributesTag(
&lastPayload_ptr,
pISF->drawAttrs,
&payloadSize);
if (err != OK)
return err;
}
/* Transform */
if (transformList_ptr)
{
err = createTransformTag(
&lastPayload_ptr,
transformList_ptr,
&payloadSize);
if (err != OK)
return err;
}
/* Strokes */
if(pISF->strokes)
{
err = createStrokesTags(
&lastPayload_ptr,
pISF->strokes,
pISF->drawAttrs,
transformList_ptr,
&payloadSize);
if (err != OK)
return err;
} /* ELSE : WTF ????????? */
/* write 0x00 as root tag id */
(*rootTag)->data[0] = 0x00;
(*rootTag)->cur_length = 1;
/* write payloadSize */
encodeMBUINT( payloadSize, *rootTag);
/* update fullPayloadSize */
*fullPayloadSize = payloadSize + (*rootTag)->cur_length;
}
return err;
}
CMessage::CMessage( CAck const & _ack, uint256 const & _actionKey, uint256 const & _id )
: m_header( (int)CPayloadKind::Ack, std::vector<unsigned char>(), GetTime(), CPubKey(), _actionKey, _id )
{
createPayload( _ack, m_payload );
}
CMessage::CMessage( CIdentifyMessage const & _identifyMessage, uint256 const & _actionKey, uint256 const & _id )
: m_header( (int)CPayloadKind::IntroductionReq, std::vector<unsigned char>(), GetTime(), CPubKey(), _actionKey, _id )
{
createPayload( _identifyMessage, m_payload );
}
