libaitrpc/src/builtin.c - diff

Return to builtin.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

Diff for /libaitrpc/src/builtin.c between versions 1.7.2.6 and 1.12

version 1.7.2.6, 2012/05/17 07:53:03	version 1.12, 2013/03/07 23:10:50
Line 12 terms:	Line 12 terms:
All of the documentation and software included in the ELWIX and AITNET	All of the documentation and software included in the ELWIX and AITNET
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012	Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
by Michael Pounov <misho@elwix.org>. All rights reserved.	by Michael Pounov <misho@elwix.org>. All rights reserved.

Redistribution and use in source and binary forms, with or without	Redistribution and use in source and binary forms, with or without
Line 49 SUCH DAMAGE.	Line 49 SUCH DAMAGE.
/* builtin RPC server functions */	/* builtin RPC server functions */

static int	static int
rpcServerClients(rpc_func_t call, int ic, array_t iv)	rpcServerClients(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_cli_t *cli;	rpc_cli_t *c;
register int i;	register int i;
int len;	int len;
const char *str = NULL;	const char *str = NULL;
char *val;	char *val;
ait_val_t v;	ait_val_t v;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

len = io_arraySize(srv->srv_clients) * STRSIZ;	len = array_Size(srv->srv_clients) * STRSIZ;
if (!(val = malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
memset(val, 0, len);	memset(val, 0, len);

for (i = 0; i < io_arraySize(srv->srv_clients); i++) {	for (i = 0; i < array_Size(srv->srv_clients); i++) {
cli = io_array(srv->srv_clients, i, rpc_cli_t*);	c = array(srv->srv_clients, i, rpc_cli_t*);
if (!cli)	if (!c)
continue;	continue;

str = io_n2addr(&cli->cli_sa, &v);	str = e_n2addr(&c->cli_sa, &v);
if (str)	if (str)
strlcat(val, (char*) str, len);	strlcat(val, (char*) str, len);
else	else
Line 83 rpcServerClients(rpc_func_t call, int ic, array_t iv	Line 83 rpcServerClients(rpc_func_t call, int ic, array_t iv
AIT_FREE_VAL(&v);	AIT_FREE_VAL(&v);
}	}

AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);	/* return values */
free(val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcServerCalls(rpc_func_t call, int ic, array_t iv)	rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_func_t *f;	rpc_func_t *f;
Line 97 rpcServerCalls(rpc_func_t call, int ic, array_t iv)	Line 98 rpcServerCalls(rpc_func_t call, int ic, array_t iv)
int len;	int len;
char *val, str[MAXPATHLEN];	char *val, str[MAXPATHLEN];

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

TAILQ_FOREACH(f, &srv->srv_funcs, func_node)	SLIST_FOREACH(f, &srv->srv_funcs, func_next)
i++;	i++;
len = i * STRSIZ;	len = i * STRSIZ;

if (!(val = malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
memset(val, 0, len);	memset(val, 0, len);

TAILQ_FOREACH(f, &srv->srv_funcs, func_node)	SLIST_FOREACH(f, &srv->srv_funcs, func_next)
if (AIT_ADDR(&f->func_name)) {	if (AIT_ADDR(&f->func_name)) {
memset(str, 0, sizeof str);	memset(str, 0, sizeof str);
snprintf(str, sizeof str, "/%hu/0x%p(%d); ", AIT_KEY(&f->func_name),	snprintf(str, sizeof str, "/%hu/0x%p; ", AIT_KEY(&f->func_name),
AIT_ADDR(&f->func_name), io_arraySize(RPC_FUNC_RETVARS(f)));	AIT_ADDR(&f->func_name));
strlcat(val, str, len);	strlcat(val, str, len);
}	}

AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);	/* return variables */
free(val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcServerSessions(rpc_func_t call, int ic, array_t iv)	rpcServerSessions(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
ait_val_t *v;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

v = io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*);	AIT_SET_I32(ait_getVars(&RPC_RETVARS(cli), 3), array_Size(srv->srv_clients));
AIT_SET_U8(v, srv->srv_session.sess_version);	AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 0), srv->srv_session.sess_version);
v = io_array(RPC_FUNC_RETVARS(call), 1, ait_val_t*);	AIT_SET_U32(ait_getVars(&RPC_RETVARS(cli), 1), srv->srv_session.sess_program);
AIT_SET_U32(v, srv->srv_session.sess_program);	AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 2), srv->srv_session.sess_process);
v = io_array(RPC_FUNC_RETVARS(call), 2, ait_val_t*);
AIT_SET_U8(v, srv->srv_session.sess_process);
v = io_array(RPC_FUNC_RETVARS(call), 3, ait_val_t*);
AIT_SET_I32(v, io_arraySize(srv->srv_clients));

return 0;	return 0;
}	}

static int	static int
rpcServerShutdown(rpc_func_t call, int ic, array_t iv)	rpcServerShutdown(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

	rpc_freeCli(cli);

srv->srv_kill = 1;	srv->srv_kill = 1;

return 0;	return 0;
}	}

static int	static int
rpcServerPing(rpc_func_t call, int ic, array_t iv)	rpcServerPing(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	if (rpc->call_req.flags == RPC_REPLY)
	AIT_SET_U16(ait_getVars(&RPC_RETVARS(cli), 0), ntohs(rpc->call_seq));
srv = RPC_FUNC_SERVER(call);

return 0;	return 0;
}	}

/* ---------------------------------------------------- */	/* ---------------------------------------------------- */

static int	static int
rpcBLOBServerShutdown(rpc_func_t call, int ic, array_t iv)	rpcBLOBServerShutdown(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

srv->srv_blob.kill = 1;	rpc_freeBLOBCli(cli);

	srv->srv_blob.kill = 1;
return 0;	return 0;
}	}

static int	static int
rpcBLOBServerVars(rpc_func_t call, int ic, array_t iv)	rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_blob_t *b;	rpc_blob_t *b;
Line 191 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i	Line 188 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i
char *val, str[64];	char *val, str[64];
int len;	int len;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

if (srv->srv_blob.kill) {	if (srv->srv_blob.kill) {
AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
return 1;	return 1;
}	}

Line 204 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i	Line 201 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i
len = i * sizeof str;	len = i * sizeof str;

if (!len) {	if (!len) {
AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "");	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "");
return 0;	return 0;
}	}

if (!(val = malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
Line 220 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i	Line 217 rpcBLOBServerVars(rpc_func_t call, int ic, array_t i
strlcat(val, str, len);	strlcat(val, str, len);
}	}

AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
free(val);	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcBLOBServerClients(rpc_func_t call, int ic, array_t iv)	rpcBLOBServerClients(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_cli_t *cli;	rpc_cli_t *c;
register int i;	register int i;
int len;	int len;
const char *str = NULL;	const char *str = NULL;
char *val;	char *val;
ait_val_t v;	ait_val_t v;

RPC_CALLBACK_CHECK_INPUT(call);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_FUNC_SERVER(call);	srv = RPC_SRV_SERVER(cli);

if (srv->srv_blob.kill) {	if (srv->srv_blob.kill) {
AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
return 1;	return 1;
}	}

len = io_arraySize(srv->srv_blob.clients) * STRSIZ;	len = array_Size(srv->srv_blob.clients) * STRSIZ;
if (!(val = malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
memset(val, 0, len);	memset(val, 0, len);

for (i = 0; i < io_arraySize(srv->srv_clients); i++) {	for (i = 0; i < array_Size(srv->srv_clients); i++) {
cli = io_array(srv->srv_blob.clients, i, rpc_cli_t*);	c = array(srv->srv_blob.clients, i, rpc_cli_t*);
if (!cli)	if (!c)
continue;	continue;

str = io_n2addr(&cli->cli_sa, &v);	str = e_n2addr(&c->cli_sa, &v);
if (str)	if (str)
strlcat(val, (char*) str, len);	strlcat(val, (char*) str, len);
else	else
Line 265 rpcBLOBServerClients(rpc_func_t *call, int ic, array_t	Line 262 rpcBLOBServerClients(rpc_func_t *call, int ic, array_t
AIT_FREE_VAL(&v);	AIT_FREE_VAL(&v);
}	}

AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
free(val);	e_free(val);
return 0;	return 0;
}	}

/* ----------------------------------------------------------------- */	/* ----------------------------------------------------------------- */

/*	/*
	* rpc_register_srvPing() - Register ping service function
	*
	* @srv = RPC server instance
	* return: -1 error or 0 ok
	*/
	inline int
	rpc_register_srvPing(rpc_srv_t * __restrict srv)
	{
	if (!srv)
	return -1;

	if (rpc_srv_registerCall(srv, CALL_SRVPING, rpcServerPing) < 1)
	return -1;

	return 0;
	}

	/*
* rpc_register_srvServices() - Register internal service functions	* rpc_register_srvServices() - Register internal service functions
*	*
* @srv = RPC server instance	* @srv = RPC server instance
Line 284 rpc_register_srvServices(rpc_srv_t * __restrict srv)	Line 299 rpc_register_srvServices(rpc_srv_t * __restrict srv)
if (!srv)	if (!srv)
return -1;	return -1;

if (rpc_srv_registerCall(srv, CALL_SRVSHUTDOWN, rpcServerShutdown, 0) < 1)	if (rpc_srv_registerCall(srv, CALL_SRVSHUTDOWN, rpcServerShutdown) < 1)
return -1;	return -1;
if (rpc_srv_registerCall(srv, CALL_SRVCLIENTS, rpcServerClients, 1) < 1)	if (rpc_srv_registerCall(srv, CALL_SRVCLIENTS, rpcServerClients) < 1)
return -1;	return -1;
if (rpc_srv_registerCall(srv, CALL_SRVSESSIONS, rpcServerSessions, 4) < 1)	if (rpc_srv_registerCall(srv, CALL_SRVSESSIONS, rpcServerSessions) < 1)
return -1;	return -1;
if (rpc_srv_registerCall(srv, CALL_SRVCALLS, rpcServerCalls, 1) < 1)	if (rpc_srv_registerCall(srv, CALL_SRVCALLS, rpcServerCalls) < 1)
return -1;	return -1;

return 0;	return 0;
Line 308 rpc_register_blobServices(rpc_srv_t * __restrict srv)	Line 323 rpc_register_blobServices(rpc_srv_t * __restrict srv)
if (!srv)	if (!srv)
return -1;	return -1;

if (rpc_srv_registerCall(srv, CALL_BLOBSHUTDOWN, rpcBLOBServerShutdown, 0) < 1)	if (rpc_srv_registerCall(srv, CALL_BLOBSHUTDOWN, rpcBLOBServerShutdown) < 1)
return -1;	return -1;
if (rpc_srv_registerCall(srv, CALL_BLOBCLIENTS, rpcBLOBServerClients, 1) < 1)	if (rpc_srv_registerCall(srv, CALL_BLOBCLIENTS, rpcBLOBServerClients) < 1)
return -1;	return -1;
if (rpc_srv_registerCall(srv, CALL_BLOBVARS, rpcBLOBServerVars, 1) < 1)	if (rpc_srv_registerCall(srv, CALL_BLOBVARS, rpcBLOBServerVars) < 1)
return -1;	return -1;

return 0;	return 0;

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.7.2.6
changed lines
	Added in v.1.12