libaitrpc/src/cli.c - diff

Return to cli.c CVS log

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

Diff for /libaitrpc/src/cli.c between versions 1.1.1.1 and 1.1.1.1.2.7

version 1.1.1.1, 2010/06/18 01:48:06	version 1.1.1.1.2.7, 2011/03/15 15:13:22
Line 10	Line 10


/*	/*
	* rpc_cli_openBLOBClient() Connect to BLOB Server
	* @rpccli = RPC Client session
	* @Port = Port for bind server, if Port == 0 default port is selected
	* return: NULL == error or !=NULL connection to BLOB server established
	*/
	rpc_cli_t *
	rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, u_short Port)
	{
	rpc_cli_t *cli = NULL;
	struct sockaddr_in sin;
	struct sockaddr_in6 sin6;

	if (!rpccli \|\| (rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6)) {
	rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to BLOB server ...\n");
	return NULL;
	}
	if (!Port)
	Port = RPC_DEFPORT + 1;

	cli = malloc(sizeof(rpc_cli_t));
	if (!cli) {
	LOGERR;
	return NULL;
	} else
	memcpy(cli, rpccli, sizeof(rpc_cli_t));

	if (rpccli->cli_sa.sa_family == AF_INET) {
	memcpy(&sin, &rpccli->cli_sa, sizeof sin);
	sin.sin_port = htons(Port);
	memcpy(&cli->cli_sa, &sin, sizeof(struct sockaddr));
	} else {
	memcpy(&sin6, &rpccli->cli_sa, sizeof sin6);
	sin6.sin6_port = htons(Port);
	memcpy(&cli->cli_sa, &sin6, sizeof(struct sockaddr));
	}

	cli->cli_sock = socket(cli->cli_sa.sa_family, SOCK_STREAM, 0);
	if (cli->cli_sock == -1) {
	LOGERR;
	free(cli);
	return NULL;
	}
	if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) {
	LOGERR;
	free(cli);
	return NULL;
	}

	return cli;
	}

	/*
	* rpc_cli_closeBLOBClient() Close connection to BLOB server and free resources
	* @cli = BLOB Client session
	* return: none
	*/
	void
	rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli)
	{
	if (!cli) {
	rpc_SetErr(EINVAL, "Error:: Can`t close connection because parameter is null!\n");
	return;
	}

	shutdown(cli->cli_sock, SHUT_RDWR);
	close(cli->cli_sock);

	free(cli);
	cli = NULL;
	}

	// --------------------------------------------------------------

	/*
* rpc_cli_openClient() Connect to RPC Server	* rpc_cli_openClient() Connect to RPC Server
* @ProgID = ProgramID for RPC session request	* @ProgID = ProgramID for RPC session request
* @ProcID = ProcessID for RPC session request	* @ProcID = ProcessID for RPC session request
Line 144 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 218 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
int ret = 0, Limit = 0;	int ret = 0, Limit = 0;
register int i;	register int i;
rpc_val_t *v;	rpc_val_t *v;
struct timeval tv = { DEF_CLI_TIMEOUT, 0 };	struct timeval tv = { DEF_RPC_TIMEOUT, 0 };

FD_ZERO(&fds);	FD_ZERO(&fds);
memset(buf, 0, BUFSIZ);	memset(buf, 0, BUFSIZ);
Line 189 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 263 rpc_cli_execCall(rpc_cli_t cli, const char csModule,

memcpy(data, in_vals[i].val.string, in_vals[i].val_len);	memcpy(data, in_vals[i].val.string, in_vals[i].val_len);
v[i].val.string = (int8_t) ((void) data - (void*) v);	v[i].val.string = (int8_t) ((void) data - (void*) v);
data += in_vals[i].val_len;	data += in_vals[i].val_len + 1;
Limit += in_vals[i].val_len;	Limit += in_vals[i].val_len + 1;
break;	break;
case array:
if (Limit + in_vals[i].val_len > BUFSIZ) {
ret = -7;
break;
}

memcpy(data, in_vals[i].val.array, in_vals[i].val_len);
v[i].val.array = (int8_t*) ((void) data - (void*) v);
data += in_vals[i].val_len;
Limit += in_vals[i].val_len;
break;
default:	default:
break;	break;
}	}
Line 217 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 280 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
return -1;	return -1;
}	}
if (ret != Limit) {	if (ret != Limit) {
rpc_SetErr(EBADMSG, "Error:: in send RPC request, should be send %d bytes, really is %d\n",	rpc_SetErr(ECANCELED, "Error:: in send RPC request, should be send %d bytes, really is %d\n",
Limit, ret);	Limit, ret);
return -9;	return -9;
}	}
Line 237 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 300 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
}	}
if (!ret) // receive EOF	if (!ret) // receive EOF
return 0;	return 0;
if (ret < sizeof(struct tagRPCCall)) {	if (ret < sizeof(struct tagRPCRet)) {
rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n");	rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n");
return -4;	return -4;
} else	} else
Line 246 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 309 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
if (memcmp(&rrpc->ret_session, cli->cli_parent, sizeof rrpc->ret_session)) {	if (memcmp(&rrpc->ret_session, cli->cli_parent, sizeof rrpc->ret_session)) {
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");	rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");
return -5;	return -5;
}	} else
	Limit = sizeof(struct tagRPCRet);
if (rrpc->ret_retcode < 0 && rrpc->ret_errno) {	if (rrpc->ret_retcode < 0 && rrpc->ret_errno) {
rpc_SetErr(rrpc->ret_errno, "Error::Server side: %s\n", strerror(rrpc->ret_errno));	rpc_SetErr(rrpc->ret_errno, "Error::Server side: %d %s\n",
	rrpc->ret_retcode, strerror(rrpc->ret_errno));
return -6;	return -6;
}	}
	if (rrpc->ret_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {
	rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too big ...\n");
	return -7;
	} else
	Limit += rrpc->ret_argc * sizeof(rpc_val_t);
// RPC is OK! Go decapsulate variables ...	// RPC is OK! Go decapsulate variables ...
if (rrpc->ret_argc) {	if (rrpc->ret_argc) {
*out_argc = rrpc->ret_argc;	*out_argc = rrpc->ret_argc;
Line 260 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 330 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
*out_argc = 0;	*out_argc = 0;
return -1;	return -1;
} else	} else
Limit = rrpc->ret_argc * sizeof(rpc_val_t);	memcpy(*out_vals, buf + sizeof(struct tagRPCRet), Limit - sizeof(struct tagRPCRet));
memcpy(*out_vals, buf + sizeof(struct tagRPCRet), Limit);
// RPC received variables types OK!	// RPC received variables types OK!
data = (u_char*) buf + sizeof(struct tagRPCRet) + Limit;	data = (u_char*) buf + Limit;
for (i = 0; i < rrpc->ret_argc; i++)	for (i = 0; i < rrpc->ret_argc; i++)
switch ((*out_vals)[i].val_type) {	switch ((*out_vals)[i].val_type) {
case buffer:	case buffer:
	if ((*out_vals)[i].val_len > BUFSIZ - Limit) {
	rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");
	free(*out_vals);
	*out_vals = NULL;
	*out_argc = 0;
	return -7;
	} else
	Limit += (*out_vals)[i].val_len;

(out_vals)[i].val.buffer = malloc((out_vals)[i].val_len);	(out_vals)[i].val.buffer = malloc((out_vals)[i].val_len);
if (!(*out_vals)[i].val.buffer) {	if (!(*out_vals)[i].val.buffer) {
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");	rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");
Line 279 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 357 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
data += (*out_vals)[i].val_len;	data += (*out_vals)[i].val_len;
break;	break;
case string:	case string:
	if ((*out_vals)[i].val_len + 1 > BUFSIZ - Limit) {
	rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");
	free(*out_vals);
	*out_vals = NULL;
	*out_argc = 0;
	return -7;
	} else
	Limit += (*out_vals)[i].val_len + 1;

(out_vals)[i].val.string = (int8_t) strdup((char*) data);	(out_vals)[i].val.string = (int8_t) strdup((char*) data);
if (!(*out_vals)[i].val.string) {	if (!(*out_vals)[i].val.string) {
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");	rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");
Line 289 rpc_cli_execCall(rpc_cli_t cli, const char csModule,	Line 376 rpc_cli_execCall(rpc_cli_t cli, const char csModule,
}	}
data += (*out_vals)[i].val_len + 1;	data += (*out_vals)[i].val_len + 1;
break;	break;
case array:
(out_vals)[i].val.array = malloc((out_vals)[i].val_len);
if (!(*out_vals)[i].val.array) {
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");
free(*out_vals);
*out_vals = NULL;
*out_argc = 0;
return -1;
} else
memcpy((out_vals)[i].val.array, data, (out_vals)[i].val_len);
data += (*out_vals)[i].val_len;
break;
default:	default:
break;	break;
}	}
} else {	} else {
*out_argc = 0;	if (out_argc)
*out_vals = NULL;	*out_argc = 0;
	if (out_vals)
	*out_vals = NULL;
}	}

return rrpc->ret_retcode;	return rrpc->ret_retcode;

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

Removed from v.1.1.1.1
changed lines
	Added in v.1.1.1.1.2.7