static KineticStatus KineticClient_ExecuteOperation(KineticOperation* operation)
{
assert(operation != NULL);
KineticStatus status = KINETIC_STATUS_INVALID;
LOGF1("Executing operation: 0x%llX", operation);
if (operation->entry != NULL &&
operation->entry->value.array.data != NULL &&
operation->entry->value.bytesUsed > 0)
{
LOGF1(" Sending PDU (0x%0llX) w/value (%zu bytes)",
operation->request, operation->entry->value.bytesUsed);
}
else {
LOGF1(" Sending PDU (0x%0llX) w/o value", operation->request);
}
// Send the request
status = KineticOperation_SendRequest(operation);
if (status != KINETIC_STATUS_SUCCESS) {
return status;
}
return KineticOperation_ReceiveAsync(operation);
}
static KineticStatus KineticClient_CreateOperation(
KineticOperation** operation,
KineticSessionHandle handle)
{
if (handle == KINETIC_HANDLE_INVALID) {
LOG0("Specified session has invalid handle value");
return KINETIC_STATUS_SESSION_EMPTY;
}
KineticConnection* connection = KineticConnection_FromHandle(handle);
if (connection == NULL) {
LOG0("Specified session is not associated with a connection");
return KINETIC_STATUS_SESSION_INVALID;
}
LOGF1("\n"
"--------------------------------------------------\n"
"Building new operation on connection @ 0x%llX", connection);
*operation = KineticAllocator_NewOperation(connection);
if (*operation == NULL) {
return KINETIC_STATUS_MEMORY_ERROR;
}
if ((*operation)->request == NULL) {
return KINETIC_STATUS_NO_PDUS_AVAVILABLE;
}
return KINETIC_STATUS_SUCCESS;
}
KineticStatus KineticSession_Connect(KineticSession * const session)
{
if (session == NULL) {
return KINETIC_STATUS_SESSION_EMPTY;
}
// Establish the connection
KINETIC_ASSERT(strlen(session->config.host) > 0);
session->socket = KineticSocket_Connect(
session->config.host, session->config.port);
if (session->socket == KINETIC_SOCKET_DESCRIPTOR_INVALID) {
LOG0("Session connection failed!");
session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
session->connected = false;
return KINETIC_STATUS_CONNECTION_ERROR;
}
session->connected = true;
bus_socket_t socket_type = session->config.useSsl ? BUS_SOCKET_SSL : BUS_SOCKET_PLAIN;
session->si = calloc(1, sizeof(socket_info) + 2 * PDU_PROTO_MAX_LEN);
if (session->si == NULL) { return KINETIC_STATUS_MEMORY_ERROR; }
bool success = Bus_RegisterSocket(session->messageBus, socket_type, session->socket, session);
if (!success) {
LOG0("Failed registering connection with client!");
goto connection_error_cleanup;
}
// Wait for initial unsolicited status to be received in order to obtain connection ID
success = KineticResourceWaiter_WaitTilAvailable(&session->connectionReady, KINETIC_CONNECTION_TIMEOUT_SECS);
if (!success) {
LOG0("Timed out waiting for connection ID from device!");
goto connection_error_cleanup;
}
LOGF1("Received connection ID %lld for session %p",
(long long)KineticSession_GetConnectionID(session), (void*)session);
return KINETIC_STATUS_SUCCESS;
connection_error_cleanup:
if (session->si != NULL) {
free(session->si);
session->si = NULL;
}
if (session->socket != KINETIC_SOCKET_DESCRIPTOR_INVALID) {
KineticSocket_Close(session->socket);
session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
session->connected = false;
return KINETIC_STATUS_CONNECTION_ERROR;
}
KineticStatus KineticSocket_WriteProtobuf(int socket, KineticPDU* pdu)
{
assert(pdu != NULL);
LOGF1("Writing protobuf (%zd bytes)...", pdu->header.protobufLength);
uint8_t* packed = (uint8_t*)malloc(pdu->header.protobufLength);
if (packed == NULL) {
LOG0("Failed allocating memory for protocol buffer");
return KINETIC_STATUS_MEMORY_ERROR;
}
size_t len = KineticProto_Message__pack(&pdu->protoData.message.message, packed);
assert(len == pdu->header.protobufLength);
ByteBuffer buffer = ByteBuffer_Create(packed, len, len);
KineticStatus status = KineticSocket_Write(socket, &buffer);
free(packed);
return status;
}
int KineticSocket_Connect(const char* host, int port)
{
char port_str[32];
struct addrinfo hints;
struct addrinfo* ai_result = NULL;
struct addrinfo* ai = NULL;
socket99_result result;
// Setup server address info
socket99_config cfg = {
.host = (char*)host,
.port = port,
.nonblocking = true,
};
sprintf(port_str, "%d", port);
// Open socket
LOGF1("Connecting to %s:%d", host, port);
if (!socket99_open(&cfg, &result)) {
char err_buf[256];
socket99_snprintf(err_buf, 256, &result);
LOGF0("Failed to open socket connection with host: %s", err_buf);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
// Configure the socket
socket99_set_hints(&cfg, &hints);
if (getaddrinfo(cfg.host, port_str, &hints, &ai_result) != 0) {
LOGF0("Failed to get socket address info: errno %d", errno);
close(result.fd);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
KineticSocket_EnableTCPNoDelay(result.fd);
for (ai = ai_result; ai != NULL; ai = ai->ai_next) {
int setsockopt_result;
int buffer_size = KINETIC_OBJ_SIZE;
#if defined(SO_NOSIGPIPE) && !defined(__APPLE__)
// On BSD-like systems we can set SO_NOSIGPIPE on the socket to
// prevent it from sending a PIPE signal and bringing down the whole
// application if the server closes the socket forcibly
int enable = 1;
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_NOSIGPIPE,
&enable, sizeof(enable));
// Allow ENOTSOCK because it allows tests to use pipes instead of
// real sockets
if (setsockopt_result != 0 && setsockopt_result != ENOTSOCK) {
LOG0("Failed to set SO_NOSIGPIPE on socket");
continue;
}
#endif
// Increase send buffer to KINETIC_OBJ_SIZE
// Note: OS allocates 2x this value for its overhead
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_SNDBUF,
&buffer_size, sizeof(buffer_size));
if (setsockopt_result == -1) {
LOG0("Error setting socket send buffer size");
continue;
}
// Increase receive buffer to KINETIC_OBJ_SIZE
// Note: OS allocates 2x this value for its overheadbuffer_size
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_RCVBUF,
&buffer_size, sizeof(buffer_size));
if (setsockopt_result == -1) {
LOG0("Error setting socket receive buffer size");
continue;
}
break;
}
freeaddrinfo(ai_result);
if (ai == NULL || result.fd == KINETIC_SOCKET_DESCRIPTOR_INVALID) {
// we went through all addresses without finding one we could bind to
LOGF0("Could not connect to %s:%d", host, port);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
else {
LOGF1("Successfully connected to %s:%d (fd=%d)", host, port, result.fd);
return result.fd;
}
}
void KineticSocket_Close(int fd)
{
if (fd == -1) {
LOG1("Not connected so no cleanup needed");
}
else {
LOGF0("Closing socket with fd=%d", fd);
if (close(fd) == 0) {
LOG2("Socket closed successfully");
}
else {
LOGF0("Error closing socket file descriptor!"
" (fd=%d, errno=%d, desc='%s')",
fd, errno, strerror(errno));
}
}
}
void KineticSocket_EnableTCPNoDelay(int fd)
{
int on = 1;
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
}
int KineticSocket_Connect(const char* host, int port, bool nonBlocking)
{
char port_str[32];
struct addrinfo hints;
struct addrinfo* ai_result = NULL;
struct addrinfo* ai = NULL;
socket99_result result;
// Setup server address info
socket99_config cfg = {
.host = (char*)host,
.port = port,
.nonblocking = nonBlocking,
};
sprintf(port_str, "%d", port);
// Open socket
LOGF0("Connecting to %s:%d", host, port);
if (!socket99_open(&cfg, &result)) {
LOGF0("Failed to open socket connection with host: status %d, errno %d",
result.status, result.saved_errno);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
// Configure the socket
socket99_set_hints(&cfg, &hints);
if (getaddrinfo(cfg.host, port_str, &hints, &ai_result) != 0) {
LOGF0("Failed to get socket address info: errno %d", errno);
close(result.fd);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
for (ai = ai_result; ai != NULL; ai = ai->ai_next) {
int setsockopt_result;
int buffer_size = KINETIC_OBJ_SIZE;
#if defined(SO_NOSIGPIPE) && !defined(__APPLE__)
// On BSD-like systems we can set SO_NOSIGPIPE on the socket to
// prevent it from sending a PIPE signal and bringing down the whole
// application if the server closes the socket forcibly
int enable = 1;
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_NOSIGPIPE,
&enable, sizeof(enable));
// Allow ENOTSOCK because it allows tests to use pipes instead of
// real sockets
if (setsockopt_result != 0 && setsockopt_result != ENOTSOCK) {
LOG0("Failed to set SO_NOSIGPIPE on socket");
continue;
}
#endif
// Increase send buffer to KINETIC_OBJ_SIZE
// Note: OS allocates 2x this value for its overhead
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_SNDBUF,
&buffer_size, sizeof(buffer_size));
if (setsockopt_result == -1) {
LOG0("Error setting socket send buffer size");
continue;
}
// Increase receive buffer to KINETIC_OBJ_SIZE
// Note: OS allocates 2x this value for its overheadbuffer_size
setsockopt_result = setsockopt(result.fd,
SOL_SOCKET, SO_RCVBUF,
&buffer_size, sizeof(buffer_size));
if (setsockopt_result == -1) {
LOG0("Error setting socket receive buffer size");
continue;
}
break;
}
freeaddrinfo(ai_result);
if (ai == NULL || result.fd == KINETIC_SOCKET_DESCRIPTOR_INVALID) {
// we went through all addresses without finding one we could bind to
LOGF0("Could not connect to %s:%d", host, port);
return KINETIC_SOCKET_DESCRIPTOR_INVALID;
}
else {
LOGF1("Successfully connected to %s:%d (fd=%d)", host, port, result.fd);
return result.fd;
}
}
void KineticSocket_Close(int socket)
{
if (socket == -1) {
LOG1("Not connected so no cleanup needed");
}
else {
LOGF0("Closing socket with fd=%d", socket);
if (close(socket) == 0) {
LOG2("Socket closed successfully");
}
else {
LOGF0("Error closing socket file descriptor!"
" (fd=%d, errno=%d, desc='%s')",
socket, errno, strerror(errno));
}
}
}
KineticWaitStatus KineticSocket_WaitUntilDataAvailable(int socket, int timeout)
{
if (socket < 0) {return -1;}
struct pollfd fd = {
.fd = socket,
.events = POLLIN,
.revents = 0,
};
int res = poll(&fd, 1, timeout);
if (res > 0) {
//if (fd.revents & POLLHUP) // hung up
if (fd.revents & POLLIN)
{
return KINETIC_WAIT_STATUS_DATA_AVAILABLE;
}
else
{
return KINETIC_WAIT_STATUS_FATAL_ERROR;
}
}
else if (res == 0)
{
return KINETIC_WAIT_STATUS_TIMED_OUT;
}
else if ((errno & (EAGAIN | EINTR)) != 0)
{
return KINETIC_WAIT_STATUS_RETRYABLE_ERROR;
}
else
{
return KINETIC_WAIT_STATUS_FATAL_ERROR;
}
}
int KineticSocket_DataBytesAvailable(int socket)
{
if (socket < 0) {return -1;}
int count = -1;
ioctl(socket, FIONREAD, &count);
return count;
}
KineticStatus KineticSocket_Read(int socket, ByteBuffer* dest, size_t len)
{
LOGF2("Reading %zd bytes into buffer @ 0x%zX from fd=%d",
len, (size_t)dest->array.data, socket);
KineticStatus status = KINETIC_STATUS_INVALID;
// Read "up to" the allocated number of bytes into dest buffer
size_t bytesToReadIntoBuffer = len;
if (dest->array.len < len) {
bytesToReadIntoBuffer = dest->array.len;
}
while (dest->bytesUsed < bytesToReadIntoBuffer) {
int opStatus;
fd_set readSet;
struct timeval timeout;
// Time out after 5 seconds
timeout.tv_sec = 5;
timeout.tv_usec = 0;
FD_ZERO(&readSet);
FD_SET(socket, &readSet);
opStatus = select(socket + 1, &readSet, NULL, NULL, &timeout);
if (opStatus < 0) { // Error occurred
LOGF0("Failed waiting to read from socket!"
" status=%d, errno=%d, desc='%s'",
opStatus, errno, strerror(errno));
return KINETIC_STATUS_SOCKET_ERROR;
}
else if (opStatus == 0) { // Timeout occurred
LOG0("Timed out waiting for socket data to arrive!");
return KINETIC_STATUS_SOCKET_TIMEOUT;
}
else if (opStatus > 0) { // Data available to read
// The socket is ready for reading
opStatus = read(socket,
&dest->array.data[dest->bytesUsed],
dest->array.len - dest->bytesUsed);
// Retry if no data yet...
if (opStatus == -1 &&
((errno == EINTR) ||
(errno == EAGAIN) ||
(errno == EWOULDBLOCK)
)) {
continue;
}
else if (opStatus <= 0) {
LOGF0("Failed to read from socket!"
" status=%d, errno=%d, desc='%s'",
opStatus, errno, strerror(errno));
return KINETIC_STATUS_SOCKET_ERROR;
}
else {
dest->bytesUsed += opStatus;
LOGF3("Received %d bytes (%zd of %zd)",
opStatus, dest->bytesUsed, len);
}
}
}
// Flush any remaining data, in case of a truncated read w/short dest buffer
if (dest->bytesUsed < len) {
bool abortFlush = false;
uint8_t* discardedBytes = malloc(len - dest->bytesUsed);
if (discardedBytes == NULL) {
LOG0("Failed allocating a socket read discard buffer!");
abortFlush = true;
status = KINETIC_STATUS_MEMORY_ERROR;
}
while (!abortFlush && dest->bytesUsed < len) {
int opStatus;
fd_set readSet;
struct timeval timeout;
size_t remainingLen = len - dest->bytesUsed;
// Time out after 5 seconds
timeout.tv_sec = 5;
timeout.tv_usec = 0;
FD_ZERO(&readSet);
FD_SET(socket, &readSet);
opStatus = select(socket + 1, &readSet, NULL, NULL, &timeout);
if (opStatus < 0) { // Error occurred
LOGF0("Failure trying to flush read socket data!"
" status=%d, errno=%d, desc='%s'",
status, errno, strerror(errno));
abortFlush = true;
status = KINETIC_STATUS_SOCKET_ERROR;
continue;
}
else if (opStatus == 0) { // Timeout occurred
LOG0("Timed out waiting to flush socket data!");
abortFlush = true;
status = KINETIC_STATUS_SOCKET_TIMEOUT;
continue;
}
else if (opStatus > 0) { // Data available to read
// The socket is ready for reading
opStatus = read(socket, discardedBytes, remainingLen);
// Retry if no data yet...
if (opStatus == -1 &&
((errno == EINTR) ||
(errno == EAGAIN) ||
(errno == EWOULDBLOCK)
)) {
continue;
}
else if (opStatus <= 0) {
LOGF0("Failed to read from socket while flushing!"
" status=%d, errno=%d, desc='%s'",
opStatus, errno, strerror(errno));
abortFlush = true;
status = KINETIC_STATUS_SOCKET_ERROR;
}
else {
dest->bytesUsed += opStatus;
LOGF3("Flushed %d bytes from socket read pipe (%zd of %zd)",
opStatus, dest->bytesUsed, len);
}
}
}
// Free up dynamically allocated memory before returning
if (discardedBytes != NULL) {
free(discardedBytes);
}
// Report any error that occurred during socket flush
if (abortFlush) {
LOG0("Socket read pipe flush aborted!");
assert(status == KINETIC_STATUS_SUCCESS);
return status;
}
// Report truncation of data for any variable length byte arrays
LOGF1("Socket read buffer was truncated due to buffer overrun!"
" received=%zu, copied=%zu",
len, dest->array.len);
return KINETIC_STATUS_BUFFER_OVERRUN;
}
LOGF3("Received %zd of %zd bytes requested", dest->bytesUsed, len);
return KINETIC_STATUS_SUCCESS;
}
KineticStatus KineticSocket_ReadProtobuf(int socket, KineticPDU* pdu)
{
size_t bytesToRead = pdu->header.protobufLength;
LOGF2("Reading %zd bytes of protobuf", bytesToRead);
uint8_t* packed = (uint8_t*)malloc(bytesToRead);
if (packed == NULL) {
LOG0("Failed allocating memory for protocol buffer");
return KINETIC_STATUS_MEMORY_ERROR;
}
ByteBuffer recvBuffer = ByteBuffer_Create(packed, bytesToRead, 0);
KineticStatus status = KineticSocket_Read(socket, &recvBuffer, bytesToRead);
if (status != KINETIC_STATUS_SUCCESS) {
LOG0("Protobuf read failed!");
free(packed);
return status;
}
else {
pdu->proto = KineticProto_Message__unpack(
NULL, recvBuffer.bytesUsed, recvBuffer.array.data);
}
free(packed);
if (pdu->proto == NULL) {
pdu->protobufDynamicallyExtracted = false;
LOG0("Error unpacking incoming Kinetic protobuf message!");
return KINETIC_STATUS_DATA_ERROR;
}
else {
pdu->protobufDynamicallyExtracted = true;
LOG3("Protobuf unpacked successfully!");
return KINETIC_STATUS_SUCCESS;
}
}
KineticStatus KineticPDU_ReceiveMain(KineticPDU* const response)
{
assert(response != NULL);
assert(response->connection != NULL);
const int fd = response->connection->socket;
assert(fd >= 0);
LOGF1("\nReceiving PDU via fd=%d", fd);
KineticStatus status;
KineticMessage* msg = &response->protoData.message;
// Receive the PDU header
ByteBuffer rawHeader =
ByteBuffer_Create(&response->headerNBO, sizeof(KineticPDUHeader), 0);
status = KineticSocket_Read(fd, &rawHeader, rawHeader.array.len);
if (status != KINETIC_STATUS_SUCCESS) {
LOG0("Failed to receive PDU header!");
return status;
}
else {
LOG3("PDU header received successfully");
KineticPDUHeader* headerNBO = &response->headerNBO;
response->header = (KineticPDUHeader) {
.versionPrefix = headerNBO->versionPrefix,
.protobufLength = KineticNBO_ToHostU32(headerNBO->protobufLength),
.valueLength = KineticNBO_ToHostU32(headerNBO->valueLength),
};
KineticLogger_LogHeader(1, &response->header);
}
// Receive the protobuf message
status = KineticSocket_ReadProtobuf(fd, response);
if (status != KINETIC_STATUS_SUCCESS) {
LOG0("Failed to receive PDU protobuf message!");
return status;
}
else {
LOG3("Received PDU protobuf");
KineticLogger_LogProtobuf(2, response->proto);
}
// Validate the HMAC for the recevied protobuf message
if (response->proto->authType == KINETIC_PROTO_MESSAGE_AUTH_TYPE_HMACAUTH) {
if(!KineticHMAC_Validate(
response->proto, response->connection->session.hmacKey)) {
LOG0("Received PDU protobuf message has invalid HMAC!");
msg->has_command = true;
msg->command.status = &msg->status;
msg->status.code = KINETIC_PROTO_COMMAND_STATUS_STATUS_CODE_DATA_ERROR;
return KINETIC_STATUS_DATA_ERROR;
}
else {
LOG3("Received protobuf HMAC validation succeeded");
}
}
else if (response->proto->authType == KINETIC_PROTO_MESSAGE_AUTH_TYPE_PINAUTH) {
LOG0("PIN-based authentication not yet supported!");
return KINETIC_STATUS_DATA_ERROR;
}
else if (response->proto->authType == KINETIC_PROTO_MESSAGE_AUTH_TYPE_UNSOLICITEDSTATUS) {
LOG3("Unsolicited status message is not authenticated");
}
// Extract embedded command, if supplied
KineticProto_Message* pMsg = response->proto;
if (pMsg->has_commandBytes &&
pMsg->commandBytes.data != NULL &&
pMsg->commandBytes.len > 0) {
response->command = KineticProto_command__unpack(
NULL,
pMsg->commandBytes.len,
pMsg->commandBytes.data);
}
status = KineticPDU_GetStatus(response);
if (status == KINETIC_STATUS_SUCCESS) {
LOG2("PDU received successfully!");
}
return status;
}
KineticStatus KineticPDU_ReceiveValue(int socket_desc, ByteBuffer* value, size_t value_length)
{
assert(socket_desc >= 0);
assert(value != NULL);
assert(value->array.data != NULL);
// Receive value payload
LOGF1("Receiving value payload (%lld bytes)...", value_length);
ByteBuffer_Reset(value);
KineticStatus status = KineticSocket_Read(socket_desc, value, value_length);
if (status != KINETIC_STATUS_SUCCESS) {
LOG0("Failed to receive PDU value payload!");
return status;
}
LOG1("Received value payload successfully");
KineticLogger_LogByteBuffer(3, "Value Buffer", *value);
return status;
}