uint8_t *msg_serialize_stat_msg(adm_stat_msg_t *msg, uint32_t *len)
{
uint8_t *result = NULL;
uint8_t *cursor = NULL;
uint8_t *code = NULL;
uint32_t code_size = 0;
uint8_t *list = NULL;
uint32_t list_size = 0;
Sdnv time;
DTNMP_DEBUG_ENTRY("msg_serialize_stat_msg","(0x%x, 0x%x)",
(unsigned long)msg, (unsigned long) len);
/* Step 0: Sanity Checks. */
if((msg == NULL) || (len == NULL))
{
DTNMP_DEBUG_ERR("msg_serialize_stat_msg","Bad Args",NULL);
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->NULL",NULL);
return NULL;
}
/* STEP 3: Serialize the Code. */
if((code = mid_serialize(msg->code, &code_size)) == NULL)
{
DTNMP_DEBUG_ERR("msg_serialize_stat_msg","Can't serialize code.",
NULL);
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->NULL",NULL);
return NULL;
}
/* STEP 4: Serialize the MID Collection. */
if((list = midcol_serialize(msg->generators, &list_size)) == NULL)
{
DTNMP_DEBUG_ERR("msg_serialize_stat_msg","Can't serialize code.",
NULL);
MRELEASE(code);
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->NULL",NULL);
return NULL;
}
/* Step 5: Build the timestamp SDNV. */
encodeSdnv(&time, msg->time);
/* STEP 6: Figure out the size of the entire message. */
*len = code_size + list_size + time.length;
/* STEP 7: Allocate the serialized message. */
if((result = (uint8_t*)MTAKE(*len)) == NULL)
{
DTNMP_DEBUG_ERR("msg_serialize_stat_msg","Can't alloc %d bytes", *len);
*len = 0;
MRELEASE(code);
MRELEASE(list);
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->NULL",NULL);
return NULL;
}
/* Step 8: Populate the serialized message. */
cursor = result;
memcpy(cursor,code,code_size);
cursor += code_size;
MRELEASE(code);
memcpy(cursor, time.text, time.length);
cursor += time.length;
memcpy(cursor, list, list_size);
cursor += list_size;
MRELEASE(list);
/* Step 9: Last sanity check. */
if((cursor - result) != *len)
{
DTNMP_DEBUG_ERR("msg_serialize_stat_msg","Wrote %d bytes but alloc %d",
(unsigned long) (cursor - result), *len);
*len = 0;
MRELEASE(result);
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->NULL",NULL);
return NULL;
}
DTNMP_DEBUG_EXIT("msg_serialize_stat_msg","->0x%x",(unsigned long)result);
return result;
}
uint8_t *ctrl_serialize(ctrl_exec_t *ctrl, uint32_t *len)
{
uint8_t *result = NULL;
uint8_t *cursor = NULL;
Sdnv time_sdnv;
Sdnv status_sdnv;
uint8_t *contents = NULL;
uint32_t contents_len = 0;
AMP_DEBUG_ENTRY("ctrl_serialize","(0x%x, 0x%x)",
(unsigned long)ctrl, (unsigned long) len);
/* Step 0: Sanity Checks. */
if((ctrl == NULL) || (len == NULL))
{
AMP_DEBUG_ERR("ctrl_serialize","Bad Args",NULL);
AMP_DEBUG_EXIT("ctrl_serialize","->NULL",NULL);
return NULL;
}
*len = 0;
/* Step 1: Serialize contents individually. */
encodeSdnv(&time_sdnv, ctrl->time);
encodeSdnv(&status_sdnv, ctrl->status);
if((contents = mid_serialize(ctrl->mid, &contents_len)) == NULL)
{
AMP_DEBUG_ERR("ctrl_serialize","Can't serialize MID.",NULL);
AMP_DEBUG_EXIT("ctrl_serialize","->NULL",NULL);
return NULL;
}
/* Step 2: Figure out the length. */
*len = time_sdnv.length + status_sdnv.length + sizeof(eid_t) + contents_len;
/* STEP 3: Allocate the serialized message. */
if((result = (uint8_t*)STAKE(*len)) == NULL)
{
AMP_DEBUG_ERR("ctrl_serialize","Can't alloc %d bytes", *len);
*len = 0;
SRELEASE(contents);
AMP_DEBUG_EXIT("ctrl_serialize","->NULL",NULL);
return NULL;
}
/* Step 4: Populate the serialized message. */
cursor = result;
memcpy(cursor,time_sdnv.text,time_sdnv.length);
cursor += time_sdnv.length;
memcpy(cursor,status_sdnv.text,status_sdnv.length);
cursor += status_sdnv.length;
memcpy(cursor,&(ctrl->sender),sizeof(eid_t));
cursor += sizeof(eid_t);
memcpy(cursor, contents, contents_len);
cursor += contents_len;
SRELEASE(contents);
/* Step 5: Last sanity check. */
if((cursor - result) != *len)
{
AMP_DEBUG_ERR("ctrl_serialize","Wrote %d bytes but allcated %d",
(unsigned long) (cursor - result), *len);
*len = 0;
SRELEASE(result);
AMP_DEBUG_EXIT("ctrl_serialize","->NULL",NULL);
return NULL;
}
AMP_DEBUG_EXIT("ctrl_serialize","->0x%x",(unsigned long)result);
return result;
}
