#ifndef _SOCKETCONFIGURATION_H_
#define _SOCKETCONFIGURATION_H_
-//=============================================================================
-// tcp socket configuration
-//=============================================================================
+/*
+ * =============================================================================
+ * tcp socket configuration
+ * =============================================================================
+ */
#define SOCKET_TCP_HOST "localhost"
#define SOCKET_TCP_PORT 22232
#define SOCKET_MAX_MESSAGE_SIZE 1024
#define ENV_TCP_HOST "LM_TCP_HOST"
#define ENV_TCP_PORT "LM_TCP_PORT"
-#endif // _SOCKETCONFIGURATION_H_
+#endif /* _SOCKETCONFIGURATION_H_ */
#include "socketConfiguration.h"
#include <sys/socket.h>
#include <netinet/in.h>
-#include <netdb.h> // struct hostent
+#include <netdb.h> /* struct hostent */
#include <string.h>
#include <stdio.h>
#include <sys/select.h>
-//=============================================================================
-// type definitions
-//=============================================================================
-// this data is transferred via socket
+/*
+ * =============================================================================
+ * type definitions
+ * =============================================================================
+ */
+
+/* this data is transferred via socket */
struct SocketMessagePaket
{
int size;
char data[SOCKET_MAX_MESSAGE_SIZE];
};
-// wraps socket message with management information
+/* wraps socket message with management information */
struct SocketMessage
{
unsigned int index;
struct SocketMessagePaket paket;
};
-// contains all state information
+/* contains all state information */
struct State
{
t_ilm_bool isClient;
};
-//=============================================================================
-// global variables
-//=============================================================================
+/*
+ * =============================================================================
+ * global variables
+ * =============================================================================
+ */
struct State gState;
-#endif // __SOCKETSHARED_H__
+#endif /* __SOCKETSHARED_H__ */
#include "IpcModule.h"
#include "socketShared.h"
-//-----------------------------------------------------------------------------
-// append simple data types
-//-----------------------------------------------------------------------------
+/*-----------------------------------------------------------------------------
+ * append simple data types
+ * -----------------------------------------------------------------------------
+ */
t_ilm_bool appendGenericValue(struct SocketMessage* msg, const char protocolType, const char size, const void* value)
{
- // size check: is message size reached
- if (sizeof(msg->paket) - sizeof(msg->paket.data) // header
- + msg->index + size // + data
+ /* size check: is message size reached */
+ if (sizeof(msg->paket) - sizeof(msg->paket.data) /* header */
+ + msg->index + size /* + data */
> SOCKET_MAX_MESSAGE_SIZE)
{
printf("Error: max message size exceeded.\n");
return ILM_FALSE;
}
- // append protocol type
+ /* append protocol type */
msg->paket.data[msg->index] = protocolType;
msg->index += sizeof(protocolType);
- // append size of data
+ /* append size of data */
msg->paket.data[msg->index] = size;
msg->index += sizeof(size);
- // append data
+ /* append data */
memcpy(&msg->paket.data[msg->index], value, size);
msg->index += size;
return appendGenericValue(msg, SOCKET_MESSAGE_TYPE_STRING, strlen(value), value);
}
-//-----------------------------------------------------------------------------
-// append array data types
-//-----------------------------------------------------------------------------
+/*-----------------------------------------------------------------------------
+ * append array data types
+ * -----------------------------------------------------------------------------
+ */
t_ilm_bool appendGenericArray(struct SocketMessage* msg, const char arraySize, const char protocolType, const char size, const void* value)
{
t_ilm_bool result = ILM_TRUE;
+ char i = 0;
- // TODO: size check: is message size reached?
+ /* TODO: size check: is message size reached? */
- // append array type
+ /* append array type */
msg->paket.data[msg->index] = SOCKET_MESSAGE_TYPE_ARRAY;
msg->index += sizeof(protocolType);
- // append size of array
+ /* append size of array */
msg->paket.data[msg->index] = arraySize;
msg->index += sizeof(arraySize);
- // append data for each array entry
- char i = 0;
+ /* append data for each array entry */
for (i = 0; i < arraySize; ++i)
{
result &= appendGenericValue(msg, protocolType, size, (void*)((unsigned int)value + i * size));
return appendGenericArray(msg, arraySize, SOCKET_MESSAGE_TYPE_DOUBLE, sizeof(t_ilm_float), valueArray);
}
-// TODO appendStringArray()
+/* TODO appendStringArray() */
#include "IpcModule.h"
#include "socketShared.h"
#include <stdio.h>
-#include <stdlib.h> // malloc
+#include <stdlib.h> /* malloc */
-//-----------------------------------------------------------------------------
-// get simple data types
-//-----------------------------------------------------------------------------
+/*
+ * -----------------------------------------------------------------------------
+ * get simple data types
+ * -----------------------------------------------------------------------------
+ */
t_ilm_bool getGenericValue(struct SocketMessage* msg, void* value, const char protocolType, const char expectedSize)
{
- // get protocol value from message
+ char size = 0;
+
+ /* get protocol value from message */
char readType = msg->paket.data[msg->index];
msg->index += sizeof(readType);
- // if type mismatch, return to previous state, return with error
+ /* if type mismatch, return to previous state, return with error */
if (readType != protocolType)
{
msg->index -= sizeof(readType);
return ILM_FALSE;
}
- // get size of value
- char size = msg->paket.data[msg->index];
+ /* get size of value */
+ size = msg->paket.data[msg->index];
msg->index += sizeof(size);
- // if size mismatch, return to previous state, return with error
- // exception: strings have varying length
+ /* if size mismatch, return to previous state, return with error
+ * exception: strings have varying length*/
if (protocolType != SOCKET_MESSAGE_TYPE_STRING
&& size != expectedSize)
{
return ILM_FALSE;
}
- // copy data to caller
+ /* copy data to caller */
memcpy(value, &msg->paket.data[msg->index], size);
msg->index += size;
- // if value is string, add end of string
+ /* if value is string, add end of string */
if (protocolType == SOCKET_MESSAGE_TYPE_STRING)
{
char* str = (char *)value + size;
return getGenericValue(msg, value, SOCKET_MESSAGE_TYPE_STRING, sizeof(t_ilm_const_string));
}
-//-----------------------------------------------------------------------------
-// get array data types
-//-----------------------------------------------------------------------------
+/*-----------------------------------------------------------------------------
+ * get array data types
+ *-----------------------------------------------------------------------------
+ */
t_ilm_bool getGenericArray(struct SocketMessage* msg, t_ilm_int* arraySize, void** value, const char protocolType, const char expectedSize)
{
t_ilm_bool result = ILM_TRUE;
- // get protocol value from message
+ /* get protocol value from message */
char readType = msg->paket.data[msg->index];
msg->index += sizeof(readType);
- // if type mismatch, return to previous state, return with error
+ /* if type mismatch, return to previous state, return with error */
if (readType != SOCKET_MESSAGE_TYPE_ARRAY)
{
msg->index -= sizeof(readType);
return ILM_FALSE;
}
- // get size of array
+ /* get size of array */
*arraySize = msg->paket.data[msg->index];
msg->index += sizeof(msg->paket.data[msg->index]);
- // create array for result and set callers pointer
+ /* create array for result and set callers pointer */
*value = malloc(*arraySize * expectedSize);
- // get all values from array
+ /* get all values from array */
char i = 0;
for (i = 0; i < *arraySize; ++i)
{
#include "IpcModule.h"
#include "socketShared.h"
#include <stdio.h>
-#include <stdlib.h> // getenv
-#include <string.h> // memset
+#include <stdlib.h> /* getenv */
+#include <string.h> /* memset */
#include <signal.h>
#include <unistd.h>
t_ilm_bool initServiceMode()
{
- // ignore broken pipe, if clients disconnect, handled in receive()
- signal(SIGPIPE, SIG_IGN);
-
t_ilm_bool isClient = ILM_FALSE;
-
t_ilm_bool result = ILM_TRUE;
+ const char* portString = getenv(ENV_TCP_PORT);
+ int port = portString ? atoi(portString) : SOCKET_TCP_PORT;
+
+ /* ignore broken pipe, if clients disconnect, handled in receive() */
+ signal(SIGPIPE, SIG_IGN);
gState.isClient = isClient;
result = ILM_FALSE;
}
- const char* portString = getenv(ENV_TCP_PORT);
- int port = SOCKET_TCP_PORT;
- if (portString)
- {
- port = atoi(portString);
- }
-
gState.serverAddrIn.sin_family = AF_INET;
gState.serverAddrIn.sin_port = htons(port);
memset(&(gState.serverAddrIn.sin_zero), '\0', 8);
- if (gState.isClient) // Client
+ if (gState.isClient) /* Client */
{
+ struct hostent* server;
const char* hostname = getenv(ENV_TCP_HOST);
if (!hostname)
{
hostname = SOCKET_TCP_HOST;
}
- struct hostent* server;
server = gethostbyname(hostname);
if (!server)
{
FD_SET(gState.socket, &gState.monitoredSockets);
gState.monitoredSocketMax = gState.socket;
}
- else // LayerManagerService
+ else /* LayerManagerService */
{
int on = 1;
setsockopt(gState.socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
t_ilm_bool initClientMode()
{
- // ignore broken pipe, if clients disconnect, handled in receive()
- signal(SIGPIPE, SIG_IGN);
-
t_ilm_bool isClient = ILM_TRUE;
-
t_ilm_bool result = ILM_TRUE;
+ const char* portString = getenv(ENV_TCP_PORT);
+ int port = portString ? atoi(portString) : SOCKET_TCP_PORT;
+
+ /* ignore broken pipe, if clients disconnect, handled in receive() */
+ signal(SIGPIPE, SIG_IGN);
gState.isClient = isClient;
result = ILM_FALSE;
}
- const char* portString = getenv(ENV_TCP_PORT);
- int port = SOCKET_TCP_PORT;
- if (portString)
- {
- port = atoi(portString);
- }
-
gState.serverAddrIn.sin_family = AF_INET;
gState.serverAddrIn.sin_port = htons(port);
memset(&(gState.serverAddrIn.sin_zero), '\0', 8);
- if (gState.isClient) // Client
+ if (gState.isClient) /* Client */
{
const char* hostname = getenv(ENV_TCP_HOST);
if (!hostname)
FD_SET(gState.socket, &gState.monitoredSockets);
gState.monitoredSocketMax = gState.socket;
}
- else // LayerManagerService
+ else /* LayerManagerService */
{
int on = 1;
setsockopt(gState.socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
}
}
- // return to default signal handling
+ /* return to default signal handling */
signal(SIGPIPE, SIG_DFL);
return ILM_TRUE;
#include <unistd.h>
-//=============================================================================
-// prototypes
-//=============================================================================
+/*=============================================================================
+ * prototypes
+ * =============================================================================
+ */
t_ilm_bool acceptClientConnection();
t_ilm_bool sendToSocket(struct SocketMessage* msg, int socketNumber);
void receiveFromSocket(struct SocketMessage* msg, int socketNumber);
-//=============================================================================
-// incoming queue handling (one select may return more than one active
-// descriptor, but receive must only return one message at a time.
-// all messages are first received and added to this queue, so no
-// messages get lost
-//=============================================================================
+/*=============================================================================
+ * incoming queue handling (one select may return more than one active
+ * descriptor, but receive must only return one message at a time.
+ * all messages are first received and added to this queue, so no
+ * messages get lost
+ * =============================================================================
+ */
struct QueueElement
{
struct SocketMessage* data;
struct SocketMessage* data = NULL;
if (oldest)
{
- data = oldest->data;
struct QueueElement* delPtr = oldest;
+ data = oldest->data;
oldest = oldest->next;
free(delPtr);
}
return data;
}
-//=============================================================================
-// message handling
-//=============================================================================
+/*=============================================================================
+ * message handling
+ * =============================================================================
+ */
t_ilm_message createMessage(t_ilm_const_string name)
{
struct SocketMessage* newMessage = (struct SocketMessage*)malloc(sizeof(struct SocketMessage));
t_ilm_bool sendToClients(t_ilm_message message, t_ilm_client_handle* receiverList, int receiverCount)
{
+ t_ilm_bool result = ILM_TRUE;
+ int i = 0;
+
struct SocketMessage* msg = (struct SocketMessage*)message;
if (gState.isClient)
{
return ILM_FALSE;
}
- t_ilm_bool result = ILM_TRUE;
- int i = 0;
-
for (i = 0; i < receiverCount; ++i)
{
int sock = (int)receiverList[i];
t_ilm_message receive(t_ilm_int timeoutInMs)
{
+ fd_set readFds = gState.monitoredSockets;
+ int numberOfFdsReady = 0;
+
struct SocketMessage* queuedMessage = getFromIncomingQueue();
if (queuedMessage)
{
return queuedMessage;
}
- fd_set readFds = gState.monitoredSockets;
-
- int numberOfFdsReady = 0;
-
if (timeoutInMs < 0)
{
numberOfFdsReady = select(gState.monitoredSocketMax + 1, &readFds, 0, 0, NULL);
{
if (gState.socket == socketNumber)
{
- // New client connected
+ /* New client connected */
msg->paket.type = IpcMessageTypeConnect;
acceptClientConnection();
continue;
}
- // receive data from socket
+ /* receive data from socket */
receiveFromSocket(msg, socketNumber);
if (msg->paket.size > 0)
{
- // new message from client
+ /* new message from client */
getString(msg, msg->name);
continue;
}
if (msg->paket.size == 0)
{
- // client disconnected
+ /* client disconnected */
msg->paket.type = IpcMessageTypeDisconnect;
close(socketNumber);
FD_CLR(socketNumber, &gState.monitoredSockets);
continue;
}
- // error
- msg->paket.type = IpcMessageTypeError;
- const char* errorMsg = (char*)strerror(errno);
- printf("TcpIpcModule: receive error socket %d (%s)\n", msg->sender, errorMsg);
+ /* error */
+ {
+ const char* errorMsg = (char*)strerror(errno);
+ msg->paket.type = IpcMessageTypeError;
+ printf("TcpIpcModule: receive error socket %d (%s)\n", msg->sender, errorMsg);
+ }
}
else
{
- // receive LayerManager response or notification
+ /* receive LayerManager response or notification */
receiveFromSocket(msg, socketNumber);
getString(msg, msg->name);
}
}
-//=============================================================================
-//private
-//=============================================================================
+/*=============================================================================
+ * private
+ * =============================================================================
+ */
t_ilm_bool acceptClientConnection()
{
t_ilm_bool result = ILM_TRUE;
t_ilm_bool sendToSocket(struct SocketMessage* msg, int socketNumber)
{
int sentBytes = 0;
+ int sendSize = 0;
int retVal = 0;
int headerSize = sizeof(msg->paket) - sizeof(msg->paket.data);
msg->paket.size = msg->index + headerSize;
- int sendSize = msg->paket.size;
+ sendSize = msg->paket.size;
do
{
{
int receivedBytes = 0;
int retVal = 0;
+ char* messageBuffer = 0;
msg->sender = socketNumber;
- // receive header in first run (contains message size)
+ /* receive header in first run (contains message size) */
msg->paket.size = sizeof(msg->paket) - sizeof(msg->paket.data);
- char* messageBuffer = (char*)&msg->paket;
+ messageBuffer = (char*)&msg->paket;
do
{
if (0 == retVal)
{
- // client disconnect
+ /* client disconnect */
msg->paket.size = 0;
}
}
projects / profile / ivi / layer-management.git / commitdiff