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.10 and 1.23

version 1.10, 2012/11/13 09:22:10	version 1.23, 2015/07/22 20:01:46
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 - 2015
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_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcServerClients(RPC_CALL_STDARGS)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_cli_t *c;	rpc_cli_t *c;
Line 62 rpcServerClients(rpc_cli_t cli, struct tagRPCCall rp	Line 62 rpcServerClients(rpc_cli_t cli, struct tagRPCCall rp
RPC_CALLBACK_CHECK_INPUT(cli);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_SRV_SERVER(cli);	srv = RPC_SRV_SERVER(cli);

len = io_arraySize(srv->srv_clients) * STRSIZ;	len = array_Size(srv->srv_clients) * STRSIZ;
if (!(val = io_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++) {
c = io_array(srv->srv_clients, i, rpc_cli_t*);	c = array(srv->srv_clients, i, rpc_cli_t*);
if (!c)	if (!c)
continue;	continue;

str = io_n2addr(&c->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 84 rpcServerClients(rpc_cli_t cli, struct tagRPCCall rp	Line 84 rpcServerClients(rpc_cli_t cli, struct tagRPCCall rp
}	}

/* return values */	/* return values */
AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
io_free(val);	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcServerCalls(RPC_CALL_STDARGS)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_func_t *f;	rpc_func_t *f;
Line 105 rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc,	Line 105 rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc,
i++;	i++;
len = i * STRSIZ;	len = i * STRSIZ;

if (!(val = io_malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
Line 120 rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc,	Line 120 rpcServerCalls(rpc_cli_t cli, struct tagRPCCall rpc,
}	}

/* return variables */	/* return variables */
AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
io_free(val);	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcServerSessions(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcServerSessions(RPC_CALL_STDARGS)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;

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

AIT_SET_I32(io_getVars(&RPC_RETVARS(cli), 3), io_arraySize(srv->srv_clients));	AIT_SET_I32(ait_getVars(&RPC_RETVARS(cli), 2), array_Size(srv->srv_clients));
AIT_SET_U8(io_getVars(&RPC_RETVARS(cli), 0), srv->srv_session.sess_version);	AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 0), srv->srv_session.sess_version);
AIT_SET_U32(io_getVars(&RPC_RETVARS(cli), 1), srv->srv_session.sess_program);	AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 1), srv->srv_session.sess_instance);
AIT_SET_U8(io_getVars(&RPC_RETVARS(cli), 2), srv->srv_session.sess_process);

return 0;	return 0;
}	}

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

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

	srv->srv_blob.kill = 1;
	if (srv->srv_blob.tid)
	pthread_kill(srv->srv_blob.tid, SIGFBLOB);
srv->srv_kill = 1;	srv->srv_kill = 1;

return 0;	return 0;
}	}

static int	static int
rpcServerPing(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcServerPing(RPC_CALL_STDARGS)
{	{
if (rpc->call_req.flags == RPC_REPLY)	if (ntohl((u_long) rpc->call_req.flags) == RPC_REPLY)
AIT_SET_U16(io_getVars(&RPC_RETVARS(cli), 0), ntohs(rpc->call_seq));	AIT_SET_U16(ait_getVars(&RPC_RETVARS(cli), 0), random() % USHRT_MAX);
return 0;	return 0;
}	}

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

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

RPC_CALLBACK_CHECK_INPUT(cli);	RPC_CALLBACK_CHECK_INPUT(cli);
srv = RPC_SRV_SERVER(cli);	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_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcBLOBServerVars(RPC_CALL_STDARGS)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_blob_t *b;	rpc_blob_t *b;
Line 190 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r	Line 192 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r
srv = RPC_SRV_SERVER(cli);	srv = RPC_SRV_SERVER(cli);

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

Line 199 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r	Line 201 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r
len = i * sizeof str;	len = i * sizeof str;

if (!len) {	if (!len) {
AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), "");	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "");
return 0;	return 0;
}	}

if (!(val = io_malloc(len))) {	if (!(val = e_malloc(len))) {
LOGERR;	LOGERR;
return -1;	return -1;
} else	} else
Line 215 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r	Line 217 rpcBLOBServerVars(rpc_cli_t cli, struct tagRPCCall r
strlcat(val, str, len);	strlcat(val, str, len);
}	}

AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
io_free(val);	e_free(val);
return 0;	return 0;
}	}

static int	static int
rpcBLOBServerClients(rpc_cli_t cli, struct tagRPCCall rpc, array_t *iv)	rpcBLOBServerClients(RPC_CALL_STDARGS)
{	{
rpc_srv_t *srv;	rpc_srv_t *srv;
rpc_cli_t *c;	rpc_cli_t *c;
Line 235 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall	Line 237 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall
srv = RPC_SRV_SERVER(cli);	srv = RPC_SRV_SERVER(cli);

if (srv->srv_blob.kill) {	if (srv->srv_blob.kill) {
AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), "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 = io_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++) {
c = io_array(srv->srv_blob.clients, i, rpc_cli_t*);	c = array(srv->srv_blob.clients, i, rpc_cli_t*);
if (!c)	if (!c)
continue;	continue;

str = io_n2addr(&c->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 260 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall	Line 262 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall
AIT_FREE_VAL(&v);	AIT_FREE_VAL(&v);
}	}

AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);	AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
io_free(val);	e_free(val);
return 0;	return 0;
}	}

Line 273 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall	Line 275 rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall
* @srv = RPC server instance	* @srv = RPC server instance
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
inline int	int
rpc_register_srvPing(rpc_srv_t * __restrict srv)	rpc_register_srvPing(rpc_srv_t * __restrict srv)
{	{
if (!srv)	if (!srv)

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

Removed from v.1.10
changed lines
	Added in v.1.23