libmsgque

The C Application-Server Project

INDEX

OBJECT CREATION AND DELETION
OBJECT CONFIGURATION
LINK CREATION AND DELETION
ADDING SERVICES
SEND DATA
READ DATA
SLAVE OBJECT
BUFFER OBJECT
EXCEPTION OBJECT

The msgque project is an infrastructure to link software together to act like a single software. To link mean distributing work from one software to an other software an wait or not wait for an answer. The linking is done using unix or inet domain sockets and is based on packages send from one software to an other software and back. The msgque project is used to handle all the different aspects for setup and maintain the link and is responsible for:

starting and stopping the server application
starting and stopping the communication interface
sending and receiving package data
reading and writing data from or into a package
setup and maintain the event-handling for an asynchronous transfer
propagate the error messages from the server to the client

OBJECT CREATION AND DELETION

struct MqS*

The object is the user visible part of a libmsgque application link.

ctx = MqContextCreate(size, template)

Create an object ready to be used with MqLinkCreate (ctx, args) to setup an application link. Use the isConnected to check if a link is already available.

MqContextDelete(&ctx)

Delete the entire object including the application link using MqLinkDelete(ctx). The object can not be reused.

OBJECT CONFIGURATION

The configuration of an object is done using the functions starting with MqConfig... or by using command-line arguments.

static: struct MqBufferLS * init = MqInitCreate()

Initialize the process startup argument prefix. The startup-prefix have to be the name of the executable found in the PATH and additional arguments like a script name or required startup options. The startup-prefix is used for two different purpose:

To start a new entity using the --spawn command-line option
To replace the SELF argument after the "@" command-line argument

Returns:: a pointer to the init object.

Attention:: the prefix have to fit to the underlying programming language

To initialize the startup-prefix the following code have to be used:

struct MqBufferLS * init = MqInitCreate();
MqBufferLAppendC(init, "myExecutable");
MqBufferLAppendC(init, "myFirstArgument");

Attention:: the memory is owned by libmsgque -> do not free the memory

command-line: --buffersize

type: MQ_INT, get: MqConfigGetBuffersize (ctx) , set: MqConfigSetBuffersize (ctx, buffersize)

The send and receive buffersize in bytes (default: 4KB)

command-line: --debug

type: MQ_INT, get: MqConfigGetDebug (ctx) , set: MqConfigSetDebug (ctx, debug)

Debug a message-queue application. Valid values are 0 <= NUM <= 9 using 0 for "no debugging" and 9 for "maximum debugging". (default: 0)

command-line: --timeout

type: MQ_TIME_T, get: MqConfigGetTimeout (ctx) , set: MqConfigSetTimeout (ctx, timeout)

User defined timeout used for connection setup and data sending (default: 90 seconds)

command-line: --name

type: MQ_CST, get: MqConfigGetName (ctx) , set: MqConfigSetName (ctx. name)

Use STRING as basename of the new message-queue object. The name shows up in the debugging output and is used as prefix for the new created command. (default: the name of the executable)

command-line: --srvname

type: MQ_CST, get: MqConfigGetSrvName (ctx) , set: MqConfigSetSrvName (ctx, srvName)

Use STRING as a client specific prefix in the server debugging output. This is used to link debugging and error messages on the server to a specific client connection. (default: empty)

command-line: --silent

type: MQ_BOL, get: MqConfigGetIsSilent (ctx) , set: MqConfigSetIsSilent (ctx, isSilent)

Write (MQ_NO) or don't write (MQ_YES) any output to stdout or stderr. (default: write to stdout or stderr)

command-line: --string

type: MQ_BOL, get: MqConfigGetIsString (ctx) , set: MqConfigSetIsString (ctx, isString)

Use (MQ_YES), as much as possible, strings in the data-package. Convert any native data-type, like integer or double, into a string (sending) and back to native (receiving). (default: use binary)

command-line: --thread --spawn --fork

type: enum MqStartE, get: MqConfigGetStartAs (ctx) , set: MqConfigSetStartAs (ctx, startAS

Start a new server as thread or spawn a new process or fork a new process. This arguments are used with:

a server-context to start a new instance after a client connection request
on a server to create a worker with: MqSlaveWorker(ctx,id,argv)
on a client/server together with the "SELF" command-line argument: MqLinkCreate (ctx, args)

Parameters:

[in] startAs 0=default, 1=fork, 2=thread and 3=spawn

command-line: --daemon

type: MQ_CST, get: NO , set: MqConfigSetDaemon (ctx, pidfile)

Close all default IO (e.g stdout, stdin, stderr) and fork the server into the background. (default: no daemon)

Attention:: this option require the fork system-call and is not compatible with threads.

Parameters:

[in] pidfile the name of the file to write the PID into

command-line: --tcp --host --port --myhost --myport

type: MQ_CST, get: MqConfigGetIoTcpHost/Port/MyHost/MyPort , set: MqConfigSetIoTcp (ctx,host,port,myhost,myport)

Configure a tcp socket link.

Parameters:

	host	client: name of the remote host (default: localhost) server: name of the local interface (default: listen on all interfaces)
	port	client: name of the remote port server: name of the local port
	myhost	client: name of the local interface
	myport	client: name of the local port

Attention:: named ports are supported as well

command-line: --uds --file

type: MQ_CST, get: MqConfigGetIoUdsFile , set: MqConfigSetIoUds (ctx, file)

Use a uds (http://en.wikipedia.org/wiki/Unix_domain_socket) socket link. The uds communication is usually 50% faster than a local tcp communication but only available on UNIX.

Parameters:

[in] file the name of the uds file

command-line: --pipe --socket

type: MQ_SOCK, get: MqConfigGetIoPipeSocket , set: MqConfigSetIoPipe (ctx, socket)

Start a pipe server to listen on socket. This is the default mode to start a server. The socket option is special because it is used for internal purpose to submit the socket from the client to the server started as pipe by the client.

Parameters:

[in] socket the file-descriptor number. The only public usage for this option is to serve as interface for an existing tool like (x)inetd. The (x)inetd tool is a UNIX service to listen on a tcp/ip port and start for every connection the proper entry from the file /etc/(x)inetd.conf with the file-descriptor 0 as send/recv socket handle.

master

type: MqC, get: MqConfigGetMaster (ctx) , set: SLAVE OBJECT

return the master if ctx is a slave-context or NULL if ctx is not a slave-context. !Only a SLAVE has a master!

ctxId

type: MQ_SIZE, get: MqConfigGetCtxId (ctx) , set: NO

return an identifier as integer and is unique per parent-context. The parent-context is always 0 and every new child-context get a new identifier by adding 1.

token

type: MQ_CST, get: MqConfigGetToken (ctx) , set: NO

return the current TOKEN IDENTIFIER and is only useful in a service callback. This command is needed on the server to implement a generic service (A MqServiceCreate(ctx,token,fService,data,fFree) with different TOKEN IDENTIFIER but with the same service callback).

isConnected

type: MQ_BOL, get: MqConfigGetIsConnected (ctx) , set: NO

Is the libmsgque context connected ? A context is connected if the MqLinkCreate (ctx, args) command was successful and a context is NOT connected if a) the object has just been created or b) the link was deleted with MqLinkDelete(ctx)

isServer

type: MQ_BOL, get: MqConfigGetIsServer (ctx) , set: IServerSetup or IServerCleanup

True if object is a server object (default: MQ_NO, be a client)

isParent

type: MQ_BOL, get: MqConfigGetIsParent (ctx) , set: NO

True if object is a parent object (default: MQ_YES, be a parent)

isSlave

type: MQ_BOL, get: MqConfigGetIsSlave (ctx) , set: NO

True if object is a slave object (default: MQ_NO, not be a slave)

IServerSetup

type: Interface, get: NO , set: MqConfigSetServerSetup (ctx, fFunc, data, fFree, fCopy)

Interface to define a server libmsgque object. This Interface define the ServerSetup callback called at MqLinkCreate (ctx, args) to define the services or to initialize context specific variables. This interface set the isServer configuration value to MQ_YES.

IServerCleanup

type: Interface, get: NO , set: MqConfigSetServerCleanup (ctx, fFunc, data, fFree, fCopy)

Interface to define a server libmsgque object. This Interface define the ServerCleanup callback called at MqLinkDelete(ctx) to free context specific variables. This interface set the isServer configuration value to MQ_YES.

IFilterFTR

type: Interface, get: NO , set: MqConfigSetFilterFTR (ctx, fFunc, data, fFree, fCopy)

Interface required to define a filter data stream object. This Interface define the IFilterFTR callback. The callback is used to act on filter data rows. Every filter input data is a list of filter data rows and every row is a list of filter data columns. Every row is send from one filter-command to the following filter-command as FTR service request. This interface set the isServer configuration value to MQ_YES. (read more at: FILTER MODE)

IFilterEOF

type: Interface, get: NO , set: MqConfigSetFilterEOF (ctx, fFunc, data, fFree, fCopy)

Interface required to define a filter data stream object. This Interface define the IFilterEOF callback. The callback is used to act on End-Of-Filter data and is called after all IFilterFTR data was send. Sometimes the filter data can not be served as IFilterFTR data (example: sorting of the input rows need to read all rows before the data can be send to the next filter command) and the IFilterEOF callback is used to continue send IFilterFTR data rows. This interface set the isServer configuration value to MQ_YES. (read more at: FILTER MODE)

IFactory

type: Interface, get: NO , set: MqConfigSetFactory (ctx, fCreate, cData, fcFree, fcCopy, fDelete, dData, fdFree, fdCopy)

The factory pattern is used to create a new application object (read more at: MqSetupS::Factory) Without the Factory pattern only the initial startup context is available to serve incoming requests. In general every server need to provide a Factory pattern.

IBgError

type: Interface, get: NO , set: MqConfigSetBgError (ctx, fCreate, Data, fFree, fCopy)

Define an asyncrone error handler. This handler is used for handle errors send with MqSendERROR(ctx). Use MQ_INT MqErrorGetNum(ctx) and MQ_CST MqErrorGetText(ctx) to access the error.

LINK CREATION AND DELETION

To create and to destroy a link is the main purpose of the libmsgque library. A link is a client/server connection used to perform various tasks.

MqLinkCreate (ctx, args)

Create a parent-context using the OBJECT CONFIGURATION. A parent-context is responsible to setup the client/server link:

the client-parent-context create the server-parent-context
the server-parent-context wait for a client-parent-context connection request

Parameters:

`[in]`	ctx	the object from OBJECT CREATION AND DELETION
`[in]`	args	command-line arguments including the "@" item for the --pipe setup

Attention:: if the first argument after the "@" item is the string "SELF" an independent server of the current server is started. This is not a SLAVE OBJECT. The "SELF" argument is replaced by an application default setting (if available) or by arguments set with static: struct MqBufferLS * init = MqInitCreate().

MqLinkCreateChild (ctx, parent, args)

Create a child-context from a libmsgque parent-context and command-line arguments. A child is using the same process or thread as the parent but a different namespace. With a different namespace a child is able to act on different services on the shared server.

Parameters:

`[in]`	ctx	the object from OBJECT CREATION AND DELETION
`[in]`	parent	the parent object
`[in]`	args	all command-line arguments including the "@" token

MqLinkDelete(ctx)

Close the client/server link and delete the underlying communication object. All depending objects will be deleted as well like depending child-context and slave-context local and on the remote site of the link.

MqExit(ctx)

Shutdown the entire communication and exit the current process or thread.

ADDING SERVICES

To provide a service is the main purpose of a server. The MqServiceCreate(ctx,token,fService,data,fFree) method is usually added in the ServerSetup method of the IServerSetup.

enum MqErrorE ServerSetup(struct MqS * msgque) {
  MqErrorCheck(MqServiceCreate(msgque, "SRV1", SRV1, NULL, NULL));
  return MQ_OK;
error:
  return MqErrorStack(msgque->error);
}

TOKEN IDENTIFIER

The token is a 4 byte string and identifies the service. The token is used in:

SERVICE CALLBACK

A service is using a callback to act on an incoming service request. The callback is used on a server using MqServiceCreate(ctx,token,fService,data,fFree) or on a client using MqSendEND_AND_CALLBACK(ctx,token,fCallback,data,fFree).

The callback is implemented as a set of functions and data suitable for MqCallbackS.

MqServiceCreate(ctx,token,fService,data,fFree)

Create a new service listen on TOKEN IDENTIFIER and start for every incoming request a service. (on error return an EXCEPTION OBJECT)

MqServiceDelete(ctx,token)

Delete a new service listen on TOKEN IDENTIFIER . (on error return an EXCEPTION OBJECT)

MqProcessEvent(ctx,timeout,MQ_WAIT_(NO|ONCE|FOREVER))

Start the Event-Loop and check for the next event. In client mode this command is usually used together with MqSendEND_AND_CALLBACK(ctx,token,fCallback,data,fFree) to process the results.

Parameters:

`[in]`	timeout	don't wait more than TIMEOUT seconds to get an answer from the server. If no answer is available an error is raised. (default: command-line: --timeout)
`[in]`	MQ_WAIT	use flag value to define the action (default: NO) NO, don't wait for an event do just the check ONCE, use timeout seconds to wait for exact one event FOREVER, wait forever and only come back on error or on exit

SEND DATA

The Send style methods are used to build and send data using the libmsgque send data package. The data is typed using the TYPE IDENTIFIER and the methods can wait or not for an answer. During waiting the the application is still able to work on events like other libmsgque client/server links.

SendSTART(ctx);
MqSendI(ctx,num);
MqSendL_START(ctx);
 MqSendD(ctx,balance);
 MqSendC(ctx,"name of the owner");
 MqSendB(ctx,signature);
MqSendL_END(ctx);
MqErrorCheck(MqSendEND_AND_WAIT(ctx,"SRV1",MQ_TIMEOUT_USER))

MqSendSTART(ctx)

Initialize a libmsgque send data package. This method is required.

MqSendEND(ctx,token)

Send the package using TOKEN IDENTIFIER without expecting an answer (FireAndForget). (on error return an EXCEPTION OBJECT)

Attention:: if an error is raised on the server during service-processing the error is send back as asynchronous event and can be raised sometime in the future. To be sure to get the error immediately use MqSendEND_AND_WAIT(ctx,token,?timeout=MQ_TIMEOUT_USER?)

MqSendEND_AND_WAIT(ctx,token,?timeout=MQ_TIMEOUT_USER?)

Send the package using TOKEN IDENTIFIER and wait timeout seconds for an answer. (on error return an EXCEPTION OBJECT)

MqSendEND_AND_CALLBACK(ctx,token,fCallback,data,fFree)

Send the package using TOKEN IDENTIFIER and don't wait for an answer. The answer will be handled by the SERVICE CALLBACK. (on error return an EXCEPTION OBJECT)

MqSendRETURN(ctx)

Answer an incoming service-call started with MqSendEND_AND_WAIT(ctx,token,?timeout=MQ_TIMEOUT_USER?) or MqSendEND_AND_CALLBACK(ctx,token,fCallback,data,fFree). The return package is build-up like the previous service call package but with a MqSendRETURN(ctx) as final command. (on error return an EXCEPTION OBJECT)

MqSendERROR(ctx)

Send an asyncrone error to the link target. (on error return an EXCEPTION OBJECT)

MqSendFTR(ctx,timeout=MQ_TIMEOUT_USER)

Send a filter stream data package using FILTER MODE. (on error return an EXCEPTION OBJECT)

MqSendEOF(ctx,timeout=MQ_TIMEOUT_USER)

Send a filter end-of-file data package using FILTER MODE. (on error return an EXCEPTION OBJECT)

MqSend[TYPE](ctx,value)

Add an item using TYPE IDENTIFIER to the libmsgque send data package. (example: SendY)

MqSendL_START(ctx)

Start to send an embedded list item.

MqSendL_END(ctx)

Finish to send an embedded list item.

READ DATA

Read data from an incoming libmsgque read data package:

on a server to serve an incoming service-call from the client
on a client to process the return-data from a previous service-call

Reading data is a passive task in opposite to sending data which is an active task. Passive mean that the read is triggered by an incoming data-package and not by the software-workflow.

MqErrorCheck(MqReadI(ctx, &i));
MqErrorCheck(MqReadL_START(ctx, NULL));
 MqErrorCheck(MqReadD(ctx, &balance));
 MqErrorCheck(MqReadC(ctx, &owner));
 MqErrorCheck(MqReadB(ctx, &signature));
MqReadL_END(ctx);

MqRead[TYPE](ctx)

return an item using the TYPE IDENTIFIER from the libmsgque read data package. (on error return an EXCEPTION OBJECT)

MqReadU(ctx)

return a temporary BUFFER OBJECT. (on error return an EXCEPTION OBJECT)

Attention:: The object is only valid until a new libmsgque read data package has arrived.

MqReadProxy(ctx, otherCtx)

Link two libmsgque objects to direct pass a data item from one object to the other. (on error return an EXCEPTION OBJECT)

int: MqReadGetNumItems(ctx)

return the number of items left in the libmsgque read data package.

bool: MqReadItemExists(ctx)

Check if are still items in the libmsgque read data package.

MqReadUndo(ctx)

Undo the last read operation. This is useful if an error was raised or if a buffer object (returned from MqReadU(ctx)) has not the expected type. (on error return an EXCEPTION OBJECT)

MqReadL_START(ctx)

MqReadL_START(ctx,buffer)

Start to read an embedded list item. Use the current read package (buffer = NULL) or a buffer object. (on error return an EXCEPTION OBJECT)

MqReadL_END(ctx)

Finish to read an embedded list item.

SLAVE OBJECT

The master/slave link is used to create a mesh of nodes by linking different PARENT context objects together. The master control the slave.
The link is used to perform the following tasks:

report error messages from the slave to the master
to create a slave-child-context if a master-child-context is created
to delete a slave-context if a master-context is deleted

In difference to the client/server link the master/slave link connect two independent msgque-context in the same process or thread (e.g. node). This leads to the restriction that only the master-msgque-context can be a server because only one server per node is possible.

MqSlaveWorker(ctx,id,argv)

Create a worker as slave of the ctx object using the image of the ctx object self and started as an independent process or thread based on the command-line: --thread --spawn --fork argument.

Parameters:

`[in]`	ctx	the master libmsgque object as SERVER-PARENT without a CHILD
`[in]`	id	an integer used as unique identifer for the master/slave link
`[in]`	args	command-line arguments passed to the worker-client or the worker-server. all arguments prior the first @ token are added to the worker-client and the other arguments to the worker-server.

example create a worker with id 7 as thread.

MqErrorCheck(MqSlaveWorker (ctx, 7, 
  MqBufferLCreateArgsV(ctx, "--thread", "--silent", "@", "--name", "MyWorker", NULL)
);

MqSlaveCreate(ctx,id,slaveCtx)

Create a master/slave link between the ctx object and the slave object. (on error return an EXCEPTION OBJECT)

Parameters:

`[in]`	ctx	the master libmsgque object as PARENT without a CHILD
`[in]`	id	an integer used as unique identifer for the master/slave link
`[in]`	slave	the slave libmsgque object as CLIENT-PARENT without a CHILD

MqSlaveDelete(ctx,id)

Delete a slave-context from a former MqSlaveCreate(ctx,id,slaveCtx) command using the same identifier id. By default the slave-context object will be deleted if the master-context is deleted. In addition only the parent-slave-context can be deleted explicit. If id is invalid nothing will happen. (on error return an EXCEPTION OBJECT)

MqSlaveGet(ctx,id)

return the slave-context from the MqSlaveCreate(ctx,id,slaveCtx) using the same identifier id or NULL if the id is not valid or if ctx is not a master.

BUFFER OBJECT

The struct MqBufferS* object is created by MqReadU(ctx) and id used to save a typeless temporary data item from the libmsgque data package. The lifetime of the struct MqBufferS* is only the current callback up to the next read operation of the same context.

MQ_BUF buf = MqReadU(ctx);
if (buf->type == MQ_STRT)
  printf(buf->cur.C);

TYPE IDENTIFIER

A libmsgque buffer data package is type safe, this mean that every item has a type prefix and every MqRead[TYPE](ctx) or MqBufferGet[TYPE](buffer) have to match the previous MqSend[TYPE](ctx,value) with the same TYPE. One exception, the cast from and to string (TYPE=C) is allowed. The following type identifier's are available:

Y : 1 byte signed character
O : 1 byte boolean character using MQ_YES for yes or true or MQ_NO for no or wrong
S : 2 byte signed short
I : 4 byte signed integer
W : 8 byte signed long long integer
F : 4 byte float
D : 8 byte double
B : unsigned char array used for binary data
C : string data using a \0 at the end
L : list type able to hold a list of all items from above
U : typeless buffer able to hold a single item from above

MqBufferGet[TYPE](buffer)

return the data form the buffer using the TYPE IDENTIFIER. (on error return an EXCEPTION OBJECT)

buffer->type

return the type as single character of the item stored in the buffer object.

EXCEPTION OBJECT

The exception object is used to transport a libmsgque error using the ctx.

if (MqErrorCheckI(MqReadI(ctx, &i))) {
 printf(MqErrorGetText(ctx));
}

MQ_CST MqErrorGetText(ctx)

return the error message from the error object.

MQ_INT MqErrorGetNum(ctx)

return the error number from the error object. The number can be used as exit-code.

MqErrorC(ctx,prefix,errnum,message)

create a libmsgque error object but do not raise the EXCEPTION OBJECT

MqErrorSet(ctx,errnum,errorcode,message)

convert a ctx into a libmsgque conform error using the ctx object. This method is used to enable additional error processing capabilities from MqLinkDelete(ctx) or MqExit(ctx) after the exception was caught and before the application exit or the object is deleted.

MqErrorReset(ctx)

clear the libmsgque error object.

MqErrorRaise(ctx)

convert and raise an libmsgque error object into a C EXCEPTION OBJECT.

MqErrorPrint(ctx)

print an libmsgque error object to stderr and clear the libmsgque error

FILTER MODE

The filter mode is related to a special usage of the libmsgque software called a command pipeline. A command pipeline is well known from the unix shell to link different commands together to act like a single application:

    command1 | command2 | command3

A command pipeline with libmsgque queues is using the special token @ to link the commands together:

    msgcmd1 @ msgcmd2 @ msgcmd3

To create a libmsgque filter use:

IFilterFTR
IFilterEOF

and to send data to the next filter command use:

#include "string.h"
#include "msgque.h"
static enum MqErrorE  MMUL( struct MqS *ctx, MQ_PTR data) {
  MQ_DBL d1,d2;
  MqErrorCheck (MqSendSTART(ctx));
  MqErrorCheck (MqReadD(ctx, &d1));
  MqErrorCheck (MqReadD(ctx, &d2));
  MqErrorCheck (MqSendD(ctx, d1*d2));
error:
  return MqSendRETURN(ctx);
}
static enum MqErrorE ServerSetup (struct MqS *ctx, MQ_PTR data) {
  return MqServiceCreate(ctx,"MMUL", MMUL, NULL, NULL);
}
int main (int argc, MQ_CST argv[]) 
{
  struct MqBufferLS * largv = MqBufferLCreateArgs(argc, argv);
  struct MqS * ctx = MqContextCreate(0, NULL);
  MqConfigSetName (ctx, "MyMulServer");
  MqConfigSetServerSetup (ctx, ServerSetup, NULL, NULL, NULL);
  MqConfigSetDefaultFactory (ctx);
  MqErrorCheck (MqLinkCreate (ctx, &largv));
  MqErrorCheck (MqCheckForLeftOverArguments(ctx, &largv));
  MqErrorCheck (MqProcessEvent(ctx,MQ_TIMEOUT,MQ_WAIT_FOREVER));
error:
  MqExit(ctx);
}

Start mulserver.c using TCP port 7777 and create a thread for every incoming connection

> mulserver --tcp --port 7777 --thread

2. in a client call the service from 1.

#include "string.h"
#include "msgque.h"
int main (int argc, MQ_CST argv[]) 
{
  struct MqBufferLS * largv = MqBufferLCreateArgs(argc, argv);
  struct MqS * ctx = MqContextCreate(0, NULL);
  MQ_DBL d;
  MqConfigSetName (ctx, "MyMul");
  MqErrorCheck (MqLinkCreate (ctx, &largv));
  MqErrorCheck (MqCheckForLeftOverArguments(ctx, &largv));
  MqSendSTART(ctx);
  MqSendD(ctx,3.67);
  MqSendD(ctx,22.3);
  MqSendEND_AND_WAIT(ctx, "MMUL", 10);
  MqErrorCheck (MqReadD(ctx, &d));
  printf("%f\n", d);
error:
  MqExit(ctx);
}

Use mulclient.c to connect to mulserver.c using TCP port 7777:

> mulclient --tcp --port 7777

3. create a filter to wrap every column in a '<>' pair

#include "string.h"
#include "msgque.h"
static enum MqErrorE  FTR( struct MqS *ctx, MQ_PTR data) {
  MQ_CST str;
  MqSendSTART(ctx);
  while (MqReadItemExists(ctx)) {
    MqErrorCheck (MqReadC(ctx, &str));
    MqBufferSetV(ctx->temp,"<%s>", str);
    MqSendU(ctx, ctx->temp);
  }
  return MqSendFTR(ctx, 10);
error:
  return MqErrorStack (ctx);
}
int main (int argc, MQ_CST argv[]) 
{
  struct MqBufferLS * largv = MqBufferLCreateArgs(argc, argv);
  struct MqS * ctx = MqContextCreate(0, NULL);
  MqConfigSetName (ctx, "ManFilter");
  MqConfigSetFilterFTR (ctx, FTR, NULL, NULL, NULL);
  MqErrorCheck (MqLinkCreate (ctx, &largv));
  MqErrorCheck (MqCheckForLeftOverArguments(ctx, &largv));
  MqErrorCheck (MqProcessEvent(ctx,MQ_TIMEOUT,MQ_WAIT_FOREVER));
error:
  MqExit(ctx);
}

Use manfilter.c in a LibMsgque command pipeline:

> echo -e "1:2:3\na:b:c" | atool split -d : @ manfilter @ atool join -d :

KEYWORDS

C, unix, socket, message, msgque