void TranscodingTest(uint16_t version = bond::v1)
{
T from = InitRandom<T>();
typename Writer::Buffer output_buffer;
Factory<Writer>::Call(output_buffer, version, boost::bind(
bond::Marshal<bond::BuiltInProtocols, T, Writer>, from, _1));
// Trans-marshal to Simple Protocol using runtime schema
bond::OutputBuffer simple_buffer;
bond::SimpleBinaryWriter<bond::OutputBuffer> simple_writer(simple_buffer, Writer::Reader::version);
{
bond::InputBuffer input(output_buffer.GetBuffer());
bond::ProtocolType proto = bond::SelectProtocolAndApply(bond::GetRuntimeSchema<T>(), input, bond::MarshalTo(simple_writer)).first;
UT_AssertAreEqual(proto, Writer::Reader::magic);
}
{
// Trans-marshal back to Writer using compile-time schema
typename Writer::Buffer writer_buffer;
{
bond::InputBuffer input(simple_buffer.GetBuffer());
Factory<Writer>::Call(writer_buffer, version, boost::bind(
bond::SelectProtocolAndApply<T, bond::BuiltInProtocols, bond::InputBuffer, bond::Marshaler<Writer> >, input, boost::bind(bond::MarshalTo<bond::BuiltInProtocols, Writer>, _1)));
}
T to;
bond::InputBuffer input(writer_buffer.GetBuffer());
Unmarshal(input, to);
UT_Compare(from, to);
}
{
// Trans-marshal back to Writer using runtime schema
typename Writer::Buffer writer_buffer;
{
bond::InputBuffer input(simple_buffer.GetBuffer());
Factory<Writer>::Call(writer_buffer, version, boost::bind(
bond::SelectProtocolAndApply<bond::BuiltInProtocols, bond::InputBuffer, bond::Marshaler<Writer> >, bond::GetRuntimeSchema<T>(), input, boost::bind(bond::MarshalTo<bond::BuiltInProtocols, Writer>, _1)));
}
T to;
bond::InputBuffer input(writer_buffer.GetBuffer());
Unmarshal(input, to);
UT_Compare(from, to);
}
}
AJ_Status AJ_UnmarshalArg(AJ_Message* msg, AJ_Arg* arg)
{
AJ_Status status;
AJ_IOBuffer* ioBuf = &msg->bus->sock.rx;
AJ_Arg* container = msg->outer;
uint8_t* argStart = ioBuf->readPtr;
size_t consumed;
if (msg->varOffset) {
/*
* Unmarshaling a variant - get the signature from the I/O buffer
*/
const char* sig = (const char*)(ioBuf->readPtr - msg->varOffset);
msg->varOffset = 0;
status = Unmarshal(msg, &sig, arg);
} else if (container) {
/*
* Unmarshaling a component of a container use the container's signature
*/
if (container->typeId == AJ_ARG_ARRAY) {
size_t len = (uint16_t)(ioBuf->readPtr - (uint8_t*)container->val.v_data);
/*
* Return an error status if there are no more array elements.
*/
if (len == container->len) {
memset(arg, 0, sizeof(AJ_Arg));
status = AJ_ERR_NO_MORE;
} else {
const char* sig = container->sigPtr;
status = Unmarshal(msg, &sig, arg);
}
} else {
status = Unmarshal(msg, &container->sigPtr, arg);
}
} else {
const char* sig = msg->signature + msg->sigOffset;
/*
* Unmarshalling anything else use the message signature
*/
status = Unmarshal(msg, &sig, arg);
msg->sigOffset = (uint8_t)(sig - msg->signature);
}
consumed = (ioBuf->readPtr - argStart);
if (consumed > msg->bodyBytes) {
/*
* Unrecoverable
*/
status = AJ_ERR_READ;
} else {
msg->bodyBytes -= (uint16_t)consumed;
}
return status;
}
/*
* Manual page at process.def
*/
INT16 CGEN_PUBLIC CProcess::Wait()
{
const SMic* pMic = NULL; // Method invocation context of Wait()
CFunction* iCaller = NULL; // Function instance calling Wait()
// Validate and initialize // ------------------------------------
if (!((m_nState & PRC_RUNNING)|PRC_COMPLETE)) // Not running
return IERROR(this,PRC_CANTWAIT,"not started",0,0); // Forget it
if (!(pMic = CDlpObject_MicGet(_this))) return -1; // Get method invocation context
iCaller = (CFunction*)CDlpObject_OfKind("function",pMic->iCaller); // Get calling CFunction
if (!iCaller) return -1; // Must be a function!
// Wait for job to be completed // ------------------------------------
#ifdef USE_FORK
if(!m_hThread && m_hPid){ // If there is a child process by fork >>
waitpid(m_hPid,NULL,0); // Wait for child process
m_nState &= ~PRC_RUNNING; // Clear running flag
m_nState |= PRC_COMPLETE; // Set completed flag
}else // <<
#endif
dlp_join_thread(m_hThread); // Wait for the watcher thread to end
ReceiveData(); // Receive transfer data
// Aftermath // ------------------------------------
if (m_iDto) // This job was a function call
Unmarshal(m_iDto,iCaller); // Unmarshal transfer data to caller
else // This job was a program call
MIC_PUT_N(m_nRetVal); // Push process return value
return O_K; // Ok
}
// This function is deprecated, to be removed in next major release
long SDMmessage::RecvFrom(long port)
{
char buf[BUFSIZE];
long result;
long unmarshal_result;
memset(buf,0,sizeof(buf));
if(bound == IP_SOCK_INVALID)
{
bound = UDPpassive(port);
if(bound == IP_SOCK_INVALID)
{
return bound;
}
}
result = UDPserv_recv(bound,buf,BUFSIZE);
if (result <= 0)
{
return result;
}
unmarshal_result = Unmarshal(buf);
if (result < unmarshal_result)
{
return result;
}
return unmarshal_result;
}
void CMarshalled::Rebuild(BYTE* pBuffer)
{
CDarkMarshalBuffer buff;
buff.SetBuffer(pBuffer, NULL);
Unmarshal(buff);
}
AJ_Status AJ_UnmarshalMsg(AJ_BusAttachment* bus, AJ_Message* msg, uint32_t timeout)
{
AJ_Status status;
AJ_IOBuffer* ioBuf = &bus->sock.rx;
uint8_t* endOfHeader;
uint32_t hdrPad;
/*
* Clear message then set the bus
*/
memset(msg, 0, sizeof(AJ_Message));
msg->msgId = AJ_INVALID_MSG_ID;
msg->bus = bus;
/*
* Move any unconsumed data to the start of the I/O buffer
*/
AJ_IOBufRebase(ioBuf);
/*
* Load the message header
*/
while (AJ_IO_BUF_AVAIL(ioBuf) < sizeof(AJ_MsgHeader)) {
//#pragma calls = AJ_Net_Recv
status = ioBuf->recv(ioBuf, sizeof(AJ_MsgHeader) - AJ_IO_BUF_AVAIL(ioBuf), timeout);
if (status != AJ_OK) {
/*
* If there were no messages to receive check if we have any methods call that have
* timed-out and if so generate an internal error message to allow the application to
* proceed.
*/
if ((status == AJ_ERR_TIMEOUT) && AJ_TimedOutMethodCall(msg)) {
msg->hdr = (AJ_MsgHeader*)&internalErrorHdr;
msg->error = AJ_ErrTimeout;
msg->sender = AJ_GetUniqueName(msg->bus);
msg->destination = msg->sender;
status = AJ_OK;
}
return status;
}
}
/*
* Header was unmarsalled directly into the rx buffer
*/
msg->hdr = (AJ_MsgHeader*)ioBuf->bufStart;
ioBuf->readPtr += sizeof(AJ_MsgHeader);
/*
* Quick sanity check on the header - unrecoverable error if this check fails
*/
if ((msg->hdr->endianess != AJ_LITTLE_ENDIAN) && (msg->hdr->endianess != AJ_BIG_ENDIAN)) {
return AJ_ERR_READ;
}
/*
* Endian swap header info - conventiently they are contiguous in the header
*/
EndianSwap(msg, AJ_ARG_INT32, &msg->hdr->bodyLen, 3);
msg->bodyBytes = msg->hdr->bodyLen;
/*
* The header is null padded to an 8 bytes boundary
*/
hdrPad = (8 - msg->hdr->headerLen) & 7;
/*
* Load the header
*/
status = LoadBytes(ioBuf, msg->hdr->headerLen + hdrPad, 0);
if (status != AJ_OK) {
return status;
}
#ifndef NDEBUG
/*
* Check that messages are getting closed
*/
AJ_ASSERT(!currentMsg);
currentMsg = msg;
#endif
/*
* Assume an empty signature
*/
msg->signature = "";
/*
* We have the header in the buffer now we can unmarshal the header fields
*/
endOfHeader = ioBuf->bufStart + sizeof(AJ_MsgHeader) + msg->hdr->headerLen;
while (ioBuf->readPtr < endOfHeader) {
const char* fieldSig;
uint8_t fieldId;
AJ_Arg hdrVal;
/*
* Custom unmarshal the header field - signature is "(yv)" so starts off with STRUCT aligment.
*/
status = LoadBytes(ioBuf, 4, PadForType(AJ_ARG_STRUCT, ioBuf));
if (status != AJ_OK) {
break;
}
fieldId = ioBuf->readPtr[0];
fieldSig = (const char*)&ioBuf->readPtr[2];
ioBuf->readPtr += 4;
/*
* Now unmarshal the field value
*/
status = Unmarshal(msg, &fieldSig, &hdrVal);
if (status != AJ_OK) {
break;
}
/*
* Check the field has the type we expect - we ignore fields we don't know
*/
if ((fieldId <= AJ_HDR_SESSION_ID) && (TypeForHdr[fieldId] != hdrVal.typeId)) {
status = AJ_ERR_UNMARSHAL;
break;
}
/*
* Set the field value in the message
*/
switch (fieldId) {
case AJ_HDR_OBJ_PATH:
msg->objPath = hdrVal.val.v_objPath;
break;
case AJ_HDR_INTERFACE:
msg->iface = hdrVal.val.v_string;
break;
case AJ_HDR_MEMBER:
msg->member = hdrVal.val.v_string;
break;
case AJ_HDR_ERROR_NAME:
msg->error = hdrVal.val.v_string;
break;
case AJ_HDR_REPLY_SERIAL:
msg->replySerial = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_DESTINATION:
msg->destination = hdrVal.val.v_string;
break;
case AJ_HDR_SENDER:
msg->sender = hdrVal.val.v_string;
break;
case AJ_HDR_SIGNATURE:
msg->signature = hdrVal.val.v_signature;
break;
case AJ_HDR_TIMESTAMP:
msg->timestamp = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_TIME_TO_LIVE:
msg->ttl = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_SESSION_ID:
msg->sessionId = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_HANDLES:
case AJ_HDR_COMPRESSION_TOKEN:
default:
/* Ignored */
break;
}
}
if (status == AJ_OK) {
AJ_ASSERT(ioBuf->readPtr == endOfHeader);
/*
* Consume the header pad bytes.
*/
ioBuf->readPtr += hdrPad;
/*
* If the message is encrypted load the entire message body and decrypt it.
*/
if (msg->hdr->flags & AJ_FLAG_ENCRYPTED) {
status = LoadBytes(ioBuf, msg->hdr->bodyLen, 0);
if (status == AJ_OK) {
status = DecryptMessage(msg);
}
}
/*
* Toggle the AUTO_START flag so in the API no flags == 0
*
* Note we must do this after decrypting the message or message authentication will fail.
*/
msg->hdr->flags ^= AJ_FLAG_AUTO_START;
/*
* If the message looks good try to identify it.
*/
if (status == AJ_OK) {
status = AJ_IdentifyMessage(msg);
}
} else {
/*
* Consume entire header
*/
ioBuf->readPtr = endOfHeader + hdrPad;
}
if (status == AJ_OK) {
AJ_DumpMsg("RECEIVED", msg, FALSE);
} else {
/*
* Silently discard message unless in debug mode
*/
AJ_ErrPrintf(("Discarding bad message %s\n", AJ_StatusText(status)));
AJ_DumpMsg("DISCARDING", msg, FALSE);
AJ_CloseMsg(msg);
}
return status;
}
