int aries_ipc_fmt_client_recv(struct ipc_client *client, struct ipc_message_info *response)
{
struct ipc_header *resphdr;
void *data;
int bread = 0;
data = malloc(MAX_MODEM_DATA_SIZE);
memset(data, 0, MAX_MODEM_DATA_SIZE);
memset(response, 0, sizeof(struct ipc_message_info));
assert(client->handlers->read != NULL);
bread = client->handlers->read((uint8_t*) data, MAX_MODEM_DATA_SIZE, client->handlers->read_data);
if (bread < 0)
{
ipc_client_log(client, "aries_ipc_fmt_client_recv: can't receive enough bytes from modem to process incoming response!");
return -1;
}
if(data == NULL)
{
ipc_client_log(client, "aries_ipc_fmt_client_recv: we retrieve less (or fairly too much) bytes from the modem than we exepected!");
return -1;
}
resphdr = (struct ipc_header *) data;
response->mseq = resphdr->mseq;
response->aseq = resphdr->aseq;
response->group = resphdr->group;
response->index = resphdr->index;
response->type = resphdr->type;
response->cmd = IPC_COMMAND(response);
response->length = resphdr->length - sizeof(struct ipc_header);
response->data = NULL;
if(response->length > 0)
{
response->data = malloc(response->length);
memcpy(response->data, (uint8_t *) data + sizeof(struct ipc_header), response->length);
}
free(data);
ipc_client_log_recv(client, response, __func__);
return 0;
}
int aries_ipc_rfs_client_recv(struct ipc_client *client, struct ipc_message_info *response)
{
void *data;
int bread = 0;
struct rfs_hdr *rfs_hdr;
data = malloc(MAX_MODEM_DATA_SIZE);
memset(data, 0, MAX_MODEM_DATA_SIZE);
memset(response, 0, sizeof(struct ipc_message_info));
assert(client->handlers->read != NULL);
bread = client->handlers->read((uint8_t*) data, MAX_MODEM_DATA_SIZE, client->handlers->read_data);
if (bread < 0)
{
ipc_client_log(client, "aries_ipc_rfs_client_recv: can't receive enough bytes from modem to process incoming response!");
return -1;
}
rfs_hdr = (struct rfs_hdr *) data;
if(rfs_hdr->len <= 0 || rfs_hdr->len >= MAX_MODEM_DATA_SIZE || data == NULL)
{
ipc_client_log(client, "aries_ipc_rfs_client_recv: we retrieve less (or fairly too much) bytes from the modem than we exepected!");
return -1;
}
response->mseq = 0;
response->aseq = rfs_hdr->id;
response->group = IPC_GROUP_RFS;
response->index = rfs_hdr->cmd;
response->type = 0;
response->length = rfs_hdr->len - sizeof(struct rfs_hdr);
response->data = NULL;
if(response->length > 0)
{
response->data = malloc(response->length);
memcpy(response->data, (uint8_t *) (data + sizeof(struct rfs_hdr)), response->length);
}
free(data);
ipc_client_log_recv(client, response, __func__);
return 0;
}
int xmm626_sec_modem_rfs_recv(struct ipc_client *client,
struct ipc_message *message)
{
struct ipc_rfs_header *header;
void *buffer = NULL;
size_t length;
size_t count;
unsigned char *p;
int rc;
if (client == NULL || client->handlers == NULL || client->handlers->read == NULL || message == NULL)
return -1;
length = XMM626_DATA_SIZE;
buffer = calloc(1, length);
rc = client->handlers->read(client->handlers->transport_data, buffer, length);
if (rc < (int) sizeof(struct ipc_rfs_header)) {
ipc_client_log(client, "Reading RFS header failed");
goto error;
}
header = (struct ipc_rfs_header *) buffer;
if (header->length > XMM626_DATA_SIZE_LIMIT) {
ipc_client_log(client, "Invalid RFS header length: %u", header->length);
goto error;
}
ipc_rfs_message_setup(header, message);
if (header->length > sizeof(struct ipc_rfs_header)) {
message->size = header->length - sizeof(struct ipc_rfs_header);
message->data = calloc(1, message->size);
p = (unsigned char *) message->data;
count = rc - sizeof(struct ipc_rfs_header);
if (count > 0) {
memcpy(p, (void *) ((unsigned char *) buffer + sizeof(struct ipc_rfs_header)), count);
p += count;
}
while (count < message->size) {
rc = client->handlers->read(client->handlers->transport_data, p, message->size - count);
if (rc <= 0) {
ipc_client_log(client, "Reading RFS data failed");
goto error;
}
count += rc;
p += rc;
}
}
ipc_client_log_recv(client, message, __func__);
rc = 0;
goto complete;
error:
rc = -1;
complete:
if (buffer != NULL)
free(buffer);
return rc;
}
