/**
* Dispatches an AFC packet over a client.
*
* @param client The client to send data through.
* @param operation The operation to perform.
* @param data The data to send together with the header.
* @param data_length The length of the data to send with the header.
* @param payload The data to send after the header has been sent.
* @param payload_length The length of data to send after the header.
* @param bytes_sent The total number of bytes actually sent.
*
* @return AFC_E_SUCCESS on success or an AFC_E_* error value.
*/
static afc_error_t afc_dispatch_packet(afc_client_t client, uint64_t operation, const char *data, uint32_t data_length, const char* payload, uint32_t payload_length, uint32_t *bytes_sent)
{
uint32_t sent = 0;
if (!client || !client->parent || !client->afc_packet)
return AFC_E_INVALID_ARG;
*bytes_sent = 0;
if (!data || !data_length)
data_length = 0;
if (!payload || !payload_length)
payload_length = 0;
client->afc_packet->packet_num++;
client->afc_packet->operation = operation;
client->afc_packet->entire_length = sizeof(AFCPacket) + data_length + payload_length;
client->afc_packet->this_length = sizeof(AFCPacket) + data_length;
debug_info("packet length = %i", client->afc_packet->this_length);
debug_buffer((char*)client->afc_packet, sizeof(AFCPacket));
/* send AFC packet header */
AFCPacket_to_LE(client->afc_packet);
sent = 0;
service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket), &sent);
AFCPacket_from_LE(client->afc_packet);
*bytes_sent += sent;
if (sent < sizeof(AFCPacket)) {
return AFC_E_SUCCESS;
}
/* send AFC packet data (if there's data to send) */
sent = 0;
if (data_length > 0) {
debug_info("packet data follows");
debug_buffer(data, data_length);
service_send(client->parent, data, data_length, &sent);
}
*bytes_sent += sent;
if (sent < data_length) {
return AFC_E_SUCCESS;
}
sent = 0;
if (payload_length > 0) {
debug_info("packet payload follows");
debug_buffer(payload, payload_length);
service_send(client->parent, payload, payload_length, &sent);
}
*bytes_sent += sent;
if (sent < payload_length) {
return AFC_E_SUCCESS;
}
return AFC_E_SUCCESS;
}
/**
* Receives data through an AFC client and sets a variable to the received data.
*
* @param client The client to receive data on.
* @param dump_here The char* to point to the newly-received data.
* @param bytes_recv How much data was received.
*
* @return AFC_E_SUCCESS on success or an AFC_E_* error value.
*/
static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint32_t *bytes_recv)
{
AFCPacket header;
uint32_t entire_len = 0;
uint32_t this_len = 0;
uint32_t current_count = 0;
uint64_t param1 = -1;
*bytes_recv = 0;
/* first, read the AFC header */
service_receive(client->parent, (char*)&header, sizeof(AFCPacket), bytes_recv);
AFCPacket_from_LE(&header);
if (*bytes_recv == 0) {
debug_info("Just didn't get enough.");
*dump_here = NULL;
return AFC_E_MUX_ERROR;
} else if (*bytes_recv < sizeof(AFCPacket)) {
debug_info("Did not even get the AFCPacket header");
*dump_here = NULL;
return AFC_E_MUX_ERROR;
}
/* check if it's a valid AFC header */
if (strncmp(header.magic, AFC_MAGIC, AFC_MAGIC_LEN)) {
debug_info("Invalid AFC packet received (magic != " AFC_MAGIC ")!");
}
/* check if it has the correct packet number */
if (header.packet_num != client->afc_packet->packet_num) {
/* otherwise print a warning but do not abort */
debug_info("ERROR: Unexpected packet number (%lld != %lld) aborting.", header.packet_num, client->afc_packet->packet_num);
*dump_here = NULL;
return AFC_E_OP_HEADER_INVALID;
}
/* then, read the attached packet */
if (header.this_length < sizeof(AFCPacket)) {
debug_info("Invalid AFCPacket header received!");
*dump_here = NULL;
return AFC_E_OP_HEADER_INVALID;
} else if ((header.this_length == header.entire_length)
&& header.entire_length == sizeof(AFCPacket)) {
debug_info("Empty AFCPacket received!");
*dump_here = NULL;
*bytes_recv = 0;
if (header.operation == AFC_OP_DATA) {
return AFC_E_SUCCESS;
} else {
return AFC_E_IO_ERROR;
}
}
debug_info("received AFC packet, full len=%lld, this len=%lld, operation=0x%llx", header.entire_length, header.this_length, header.operation);
entire_len = (uint32_t)header.entire_length - sizeof(AFCPacket);
this_len = (uint32_t)header.this_length - sizeof(AFCPacket);
/* this is here as a check (perhaps a different upper limit is good?) */
if (entire_len > (uint32_t)MAXIMUM_PACKET_SIZE) {
fprintf(stderr, "%s: entire_len is larger than MAXIMUM_PACKET_SIZE, (%d > %d)!", __FUNCTION__, entire_len, MAXIMUM_PACKET_SIZE);
}
*dump_here = (char*)malloc(entire_len);
if (this_len > 0) {
service_receive(client->parent, *dump_here, this_len, bytes_recv);
if (*bytes_recv <= 0) {
free(*dump_here);
*dump_here = NULL;
debug_info("Did not get packet contents!");
return AFC_E_NOT_ENOUGH_DATA;
} else if (*bytes_recv < this_len) {
free(*dump_here);
*dump_here = NULL;
debug_info("Could not receive this_len=%d bytes", this_len);
return AFC_E_NOT_ENOUGH_DATA;
}
}
current_count = this_len;
if (entire_len > this_len) {
while (current_count < entire_len) {
service_receive(client->parent, (*dump_here)+current_count, entire_len - current_count, bytes_recv);
if (*bytes_recv <= 0) {
debug_info("Error receiving data (recv returned %d)", *bytes_recv);
break;
}
current_count += *bytes_recv;
}
if (current_count < entire_len) {
debug_info("WARNING: could not receive full packet (read %s, size %d)", current_count, entire_len);
}
}
if (current_count >= sizeof(uint64_t)) {
param1 = le64toh(*(uint64_t*)(*dump_here));
}
debug_info("packet data size = %i", current_count);
debug_info("packet data follows");
debug_buffer(*dump_here, current_count);
/* check operation types */
if (header.operation == AFC_OP_STATUS) {
/* status response */
debug_info("got a status response, code=%lld", param1);
if (param1 != AFC_E_SUCCESS) {
/* error status */
/* free buffer */
free(*dump_here);
*dump_here = NULL;
return (afc_error_t)param1;
}
} else if (header.operation == AFC_OP_DATA) {
/* data response */
debug_info("got a data response");
} else if (header.operation == AFC_OP_FILE_OPEN_RES) {
/* file handle response */
debug_info("got a file handle response, handle=%lld", param1);
} else if (header.operation == AFC_OP_FILE_TELL_RES) {
/* tell response */
debug_info("got a tell response, position=%lld", param1);
} else {
/* unknown operation code received */
free(*dump_here);
*dump_here = NULL;
*bytes_recv = 0;
debug_info("WARNING: Unknown operation code received 0x%llx param1=%lld", header.operation, param1);
#ifndef WIN32
fprintf(stderr, "%s: WARNING: Unknown operation code received 0x%llx param1=%lld", __func__, (long long)header.operation, (long long)param1);
#endif
return AFC_E_OP_NOT_SUPPORTED;
}
*bytes_recv = current_count;
return AFC_E_SUCCESS;
}
/**
* Dispatches an AFC packet over a client.
*
* @param client The client to send data through.
* @param data The data to send.
* @param length The length to send.
* @param bytes_sent The number of bytes actually sent.
*
* @return AFC_E_SUCCESS on success or an AFC_E_* error value.
*
* @warning set client->afc_packet->this_length and
* client->afc_packet->entire_length to 0 before calling this. The
* reason is that if you set them to different values, it indicates
* you want to send the data as two packets.
*/
static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, uint32_t length, uint32_t *bytes_sent)
{
uint32_t offset = 0;
uint32_t sent = 0;
if (!client || !client->parent || !client->afc_packet)
return AFC_E_INVALID_ARG;
*bytes_sent = 0;
if (!data || !length)
length = 0;
client->afc_packet->packet_num++;
if (!client->afc_packet->entire_length) {
client->afc_packet->entire_length = (length) ? sizeof(AFCPacket) + length : sizeof(AFCPacket);
client->afc_packet->this_length = client->afc_packet->entire_length;
}
if (!client->afc_packet->this_length) {
client->afc_packet->this_length = sizeof(AFCPacket);
}
/* We want to send two segments; buffer+sizeof(AFCPacket) to this_length
is the parameters and everything beyond that is the next packet.
(for writing) */
if (client->afc_packet->this_length != client->afc_packet->entire_length) {
offset = (uint32_t)(client->afc_packet->this_length - sizeof(AFCPacket));
debug_info("Offset: %i", offset);
if ((length) < (client->afc_packet->entire_length - client->afc_packet->this_length)) {
debug_info("Length did not resemble what it was supposed to based on packet");
debug_info("length minus offset: %i", length - offset);
debug_info("rest of packet: %i\n", client->afc_packet->entire_length - client->afc_packet->this_length);
return AFC_E_INTERNAL_ERROR;
}
/* send AFC packet header */
AFCPacket_to_LE(client->afc_packet);
sent = 0;
service_send(client->parent, (const char *)client->afc_packet, sizeof(AFCPacket), &sent);
AFCPacket_from_LE(client->afc_packet);
if (sent == 0) {
/* FIXME: should this be handled as success?! */
return AFC_E_SUCCESS;
}
*bytes_sent += sent;
/* send AFC packet data */
sent = 0;
service_send(client->parent, data, offset, &sent);
if (sent == 0) {
return AFC_E_SUCCESS;
}
*bytes_sent += sent;
debug_info("sent the first now go with the second");
debug_info("Length: %i", length - offset);
debug_info("Buffer: ");
debug_buffer(data + offset, length - offset);
sent = 0;
service_send(client->parent, data + offset, length - offset, &sent);
*bytes_sent = sent;
return AFC_E_SUCCESS;
} else {
debug_info("doin things the old way");
debug_info("packet length = %i", client->afc_packet->this_length);
debug_buffer((char*)client->afc_packet, sizeof(AFCPacket));
/* send AFC packet header */
AFCPacket_to_LE(client->afc_packet);
sent = 0;
service_send(client->parent, (const char *)client->afc_packet, sizeof(AFCPacket), &sent);
AFCPacket_from_LE(client->afc_packet);
if (sent == 0) {
return AFC_E_SUCCESS;
}
*bytes_sent += sent;
/* send AFC packet data (if there's data to send) */
if (length > 0) {
debug_info("packet data follows");
debug_buffer(data, length);
service_send(client->parent, data, length, &sent);
*bytes_sent += sent;
}
return AFC_E_SUCCESS;
}
return AFC_E_INTERNAL_ERROR;
}
