liberipc/src/eripc.c File Reference

#include "eripc.h"
#include "eripcprivate.h"
#include "eripcports.h"
#include "eripcclient.h"
#include "eripclog.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

Go to the source code of this file.

Functions
int	erIpcGetVersion ()
int	erIpcInitServer (int channelIdx, int *sockfd, int local)
int	erIpcStartServer (int channelIdx, erMessageCB callback, char *szBuffer, int *nBuf, void *data)
int	erIpcOpenServerChannel (int channelIdx, erServerChannel_t *channel)
int	erIpcGetServerFd (erServerChannel_t channel)
int	erIpcGetMessage (erServerChannel_t channel, char *szBuffer, int *nBuf)
int	erIpcStartClient (int channelIdx, erClientChannel_t *channel)

---

Function Documentation

int erIpcGetMessage	(	erServerChannel_t	channel,
		char *	szBuffer,
		int *	nBuf
	)

Get a message from the channel, will block when no message is available

Cf. erIpcOpenServerChannel

Parameters:

	channel	Communication channel
	szBuffer	Buffer that will be used by callback
	nBuf	size of szBuffer

Returns:

The file descriptor associated with the channel

Definition at line 184 of file eripc.c.

{
    char    szClientIP[INET_ADDRSTRLEN + 1];
    struct sockaddr_in clientAdr;
    socklen_t len;
    int     sockfd;
    erInternalServerChannel_t *serverChannel;
    int     nBufsize;
    int n;

    nBufsize = *nBuf;
    serverChannel = (erInternalServerChannel_t *) channel;
    sockfd = serverChannel->sockfd;

    // Blocking call.
    len = sizeof(clientAdr);
    n = recvfrom(sockfd, szBuffer, nBufsize, 0, (struct sockaddr *) &clientAdr, &len);
    szBuffer[n] = '\0';
    // Who's sending this message?
    // clientAdr.sin_addr.s_addr // 32-bit IPv4 address, network byte ordered.
    if (inet_ntop(AF_INET, &clientAdr.sin_addr, szClientIP, sizeof(szClientIP)))
    {
        ERIPC_LOGPRINTF("Message %s received from %s", szBuffer, szClientIP);
    }
    *nBuf = n;
    return 0;
}

int erIpcGetServerFd

(

erServerChannel_t

channel

)

Fetch the filedescriptor associated with the channel

Cf. erIpcOpenServerChannel

Parameters:

channel

Communication channel

Returns:

The file descriptor associated with the channel

Definition at line 176 of file eripc.c.

{
    erInternalServerChannel_t *serverChannel;

    serverChannel = (erInternalServerChannel_t *) channel;
    return serverChannel->sockfd;
}

int erIpcGetVersion

(

)

Definition at line 39 of file eripc.c.

{
    return ER_IPC_VERSION;
}

int erIpcInitServer	(	int	channelIdx,
		int *	sockfd,
		int	local
	)

Initializes the server. Only use this function when you don't want a dedicated thread for IPC handling.

Parameters:

	channelIdx	Communication channel identifier
	sockfd	The socket filedescriptor
	local	Set to 1 if only local addresses need to be served

Returns:

A value of 0 signals success

Definition at line 48 of file eripc.c.

{
    int     error;
    int     port;
    struct sockaddr_in serverAdr;
    int on = 1;

    // test code
    ERIPC_WARNPRINTF("Version: %d\n", erIpcGetVersion());


    *sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    error = setsockopt(*sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on));
    if (error)
    {
        perror("Unable to set socket options to SO_REUSEADDR");
    }

    port = erIpcGetServerPort(channelIdx);
    if (port == ER_IPC_PORT_ILLEGAL)
    {
        ERIPC_ERRORPRINTF("Could not allocate channel %d", channelIdx);
        return -1;
    }

    bzero(&serverAdr, sizeof(serverAdr));
    serverAdr.sin_family = AF_INET;
    // NOTE :
    //   Setting the address to INADDR_LOOPBACK will only allow processes running
    // on the same host to send messages to the displayMgrServer
    //   Setting the address to INADDR_ANY will allow a process on any host to 
    // send messages to the displayMgrServer
    if (local == 1)
    {
        serverAdr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    }
    else
    {
        serverAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    }
    serverAdr.sin_port = htons(port);

    error = bind(*sockfd, (struct sockaddr *) &serverAdr, sizeof(serverAdr));
    if (error)
    {
        perror("Error invoking bind");
        return -1;
    }
    else
    {
        char    szServerIP[INET_ADDRSTRLEN + 1];

        inet_ntop(AF_INET, &serverAdr.sin_addr, szServerIP, sizeof(szServerIP));
        ERIPC_WARNPRINTF("Bound successfully to %s:%d.", szServerIP, port);
    }
    return 0;
}

Here is the call graph for this function:

int erIpcOpenServerChannel	(	int	channelIdx,
		erServerChannel_t *	channel
	)

Create the server side of the IPC communication channel.

After calling this function. Use erIpcGetServerFd() to fetch the filedescriptor associated with this channel. Monitor the filedescriptor for data. When data is available use erIpcGetMessage to fetch the data.

Parameters:

	channelIdx	Communication channel identifier
	channel	Opaque datastructure that contains info on communication channel

Returns:

A value of -1 signals failure

Definition at line 147 of file eripc.c.

{
    erInternalServerChannel_t *serverChannel;
    int     sockfd;
    int     nErr;
    int     fLocal = 1;

    nErr = erIpcInitServer(channelIdx, &sockfd, fLocal);
    if (nErr != 0)
    {
        ERIPC_ERRORPRINTF("Failed to initialize IPC server");
        return -1;
    }

    serverChannel = (erInternalServerChannel_t *) malloc(sizeof(erInternalServerChannel_t));

    if (serverChannel != NULL)
    {
        *channel = (erServerChannel_t) serverChannel;
    }
    else
    {
        ERIPC_ERRORPRINTF("Out of memory.");
        return -1;
    }
    serverChannel->sockfd = sockfd;
    return 0;
}

Here is the call graph for this function:

int erIpcStartClient	(	int	channelIdx,
		erClientChannel_t *	channel
	)

Start the client side of the IPC communication channel

Parameters:

	channelIdx	Communication channel identifier
	channel	Opaque datastructure that contains info on communication channel

Returns:

A value of 0 signals success

Definition at line 213 of file eripc.c.

{
    erInternalClientChannel_t *clientChannel;
    int     port;
    int     ret;
    struct in_addr destinationAdr;

    // Note. The following variable can be turned into an argument later
    //   INADDR_LOOPBACK : "127.0.0.1"
    //   INADDR_ANY      : "0.0.0.0"
    char    szDestination[] = "127.0.0.1";
    int     sockfd;
    struct sockaddr_in serverAdr;

    clientChannel = (erInternalClientChannel_t *) malloc(sizeof(erInternalClientChannel_t));

    if (clientChannel != NULL)
    {
        *channel = (erClientChannel_t) clientChannel;
    }
    else
    {
        ERIPC_ERRORPRINTF("Out of memory.");
        return -1;
    }
    clientChannel->sockfd = -1;

    if ((ret = inet_pton(AF_INET, szDestination, &destinationAdr)) == 1)
    {
        ERIPC_LOGPRINTF("Sending messages to %s", szDestination);
    }
    else if (ret == 0)
    {
        ERIPC_WARNPRINTF("%s not a presentation IP address (not in dotted decimal format)", szDestination);
        return -1;
    }
    else
    {
        ERIPC_WARNPRINTF("Failed to convert to a numeric IP address");
        return -2;
    }

    port = erIpcGetServerPort(channelIdx);
    if (port == ER_IPC_PORT_ILLEGAL)
    {
        ERIPC_ERRORPRINTF("Could not allocate channel %d", channelIdx);
        return -1;
    }


    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    bzero(&serverAdr, sizeof(serverAdr));
    serverAdr.sin_family = AF_INET;
    serverAdr.sin_addr.s_addr = destinationAdr.s_addr;
    serverAdr.sin_port = htons(port);

    clientChannel->sockfd = sockfd;
    clientChannel->serverAdr = serverAdr;

    return 0;
}

int erIpcStartServer	(	int	channelIdx,
		erMessageCB	callback,
		char *	szBuffer,
		int *	nBuf,
		void *	data
	)

Start the server side of the IPC communication channel. Under normal circumstances this function will not return. It invokes a callback when a message is received. It requires its own thread and is the easiest way to establish the server side. Note: Use erIpcOpenServerChannel(), erIpcGetServerFd() and * erIpcGetMessage() if you don't want to create a server specific thread.

Parameters:

	channelIdx	Communication channel identifier
	callback	Will be called when a message is received
	szBuffer	Buffer that will be used by callback
	nBuf	size of szBuffer
	data	pointer to opaque datastructure.

Returns:

A value of -1 signals failure

Definition at line 108 of file eripc.c.

{
    int     sockfd;
    struct sockaddr_in clientAdr;
    socklen_t len;
    int     n;
    int     nErr;
    int     fLocal = 1;
    erMessageCB messageCallback = NULL;
    int     nBufsize;

    nErr = erIpcInitServer(channelIdx, &sockfd, fLocal);
    if (nErr != 0)
    {
        ERIPC_ERRORPRINTF("Failed to start IPC server");
        return -1;
    }

    nBufsize = *nBuf;
    messageCallback = callback;
    while (1)
    {
        char    szClientIP[INET_ADDRSTRLEN + 1];

        // Blocking call.
        len = sizeof(clientAdr);
        n = recvfrom(sockfd, szBuffer, nBufsize, 0, (struct sockaddr *) &clientAdr, &len);
        szBuffer[n] = '\0';
        // Who's sending this message?
        // clientAdr.sin_addr.s_addr // 32-bit IPv4 address, network byte ordered.
        if (inet_ntop(AF_INET, &clientAdr.sin_addr, szClientIP, sizeof(szClientIP)))
        {
            ERIPC_LOGPRINTF("Message %s received from %s", szBuffer, szClientIP);
        }
        *nBuf = n;
        messageCallback(szBuffer, nBuf, data);
    }
}

Here is the call graph for this function: