libaitrpc/src/srv.c - diff

Return to srv.c CVS log

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

Diff for /libaitrpc/src/srv.c between versions 1.1.1.1.2.12 and 1.1.1.1.2.21

version 1.1.1.1.2.12, 2010/06/24 15:23:38	version 1.1.1.1.2.21, 2010/07/08 13:05:50
Line 93 rpc_srv_dispatchCall(void *arg)	Line 93 rpc_srv_dispatchCall(void *arg)
ret = -6;	ret = -6;
} else	} else
if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)	if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)
ret = -6;	ret = -9;
else	else
argc = rpc_srv_getValsCall(f, &vals);	argc = rpc_srv_getValsCall(f, &vals);

Line 179 rpc_srv_dispatchVars(void *arg)	Line 179 rpc_srv_dispatchVars(void *arg)
rpc_cli_t *c = arg;	rpc_cli_t *c = arg;
rpc_srv_t *s;	rpc_srv_t *s;
rpc_blob_t *b;	rpc_blob_t *b;
int cx, ret;	int ret;
fd_set fds;	fd_set fds;
u_char buf[sizeof(struct tagBLOBHdr)];	u_char buf[sizeof(struct tagBLOBHdr)];
struct tagBLOBHdr *blob;	struct tagBLOBHdr *blob;
Line 190 rpc_srv_dispatchVars(void *arg)	Line 190 rpc_srv_dispatchVars(void *arg)
} else	} else
s = c->cli_parent;	s = c->cli_parent;

cx = -1;
do {	do {
// check for disable service at this moment?	// check for disable service at this moment?
if (s->srv_blob.state == disable) {	if (s->srv_blob.state == disable) {
Line 203 rpc_srv_dispatchVars(void *arg)	Line 202 rpc_srv_dispatchVars(void *arg)
ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL);	ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL);
if (ret == -1) {	if (ret == -1) {
ret = -2;	ret = -2;
} else	}
cx++;
memset(buf, 0, sizeof buf);	memset(buf, 0, sizeof buf);
if ((ret = recv(c->cli_sock, buf, sizeof buf, 0)) == -1) {	if ((ret = recv(c->cli_sock, buf, sizeof buf, 0)) == -1) {
LOGERR;	LOGERR;
Line 222 rpc_srv_dispatchVars(void *arg)	Line 221 rpc_srv_dispatchVars(void *arg)
} else	} else
blob = (struct tagBLOBHdr*) buf;	blob = (struct tagBLOBHdr*) buf;
// check BLOB packet session info	// check BLOB packet session info
if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session) \|\|	if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) {
blob->hdr_seq != cx) {	rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n");
rpc_SetErr(EINVAL, "Error:: get invalid BLOB session in seq=%d...\n", blob->hdr_seq);
ret = -5;	ret = -5;
goto makeReply;	goto makeReply;
}	}
Line 236 rpc_srv_dispatchVars(void *arg)	Line 234 rpc_srv_dispatchVars(void *arg)
blob->hdr_var);	blob->hdr_var);
ret = -6;	ret = -6;
break;	break;
}	} else
	blob->hdr_len = b->blob_len;

if (rpc_srv_blobMap(s, b) != -1) {	if (rpc_srv_blobMap(s, b) != -1) {
ret = rpc_srv_sendBLOB(c, b);	ret = rpc_srv_sendBLOB(c, b);
Line 268 rpc_srv_dispatchVars(void *arg)	Line 267 rpc_srv_dispatchVars(void *arg)
makeReply:	makeReply:
// Replay to client!	// Replay to client!
blob->hdr_cmd = ret < 0 ? error : ok;	blob->hdr_cmd = ret < 0 ? error : ok;
blob->hdr_seq = ret;	blob->hdr_ret = ret;
if ((ret = send(c->cli_sock, buf, sizeof buf, 0)) == -1) {	if ((ret = send(c->cli_sock, buf, sizeof buf, 0)) == -1) {
LOGERR;	LOGERR;
ret = -8;	ret = -8;
Line 364 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s	Line 363 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);	rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);
rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0);	rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0);
rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);	rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);
	rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);
pthread_mutex_unlock(&srv->srv_mtx);	pthread_mutex_unlock(&srv->srv_mtx);

srv->srv_blob.state = enable; // enable BLOB	srv->srv_blob.state = enable; // enable BLOB
Line 391 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)	Line 391 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);	rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS);	rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS);
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);	rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);
	rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSTATE);

for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++)	for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++)
if (c->cli_sa.sa_family)	if (c->cli_sa.sa_family)
shutdown(c->cli_sock, SHUT_RDWR);	shutdown(c->cli_sock, SHUT_RDWR);
close(srv->srv_blob.server.cli_sock);	close(srv->srv_blob.server.cli_sock);

if (srv->srv_blob.clients)	if (srv->srv_blob.clients) {
free(srv->srv_blob.clients);	free(srv->srv_blob.clients);
	srv->srv_blob.clients = NULL;
	}

pthread_mutex_lock(&srv->srv_blob.mtx);	pthread_mutex_lock(&srv->srv_blob.mtx);
while ((f = srv->srv_blob.blobs)) {	while ((f = srv->srv_blob.blobs)) {
srv->srv_blob.blobs = f->blob_next;	srv->srv_blob.blobs = f->blob_next;
	rpc_srv_blobFree(srv, f);
free(f);	free(f);
}	}
pthread_mutex_unlock(&srv->srv_blob.mtx);	pthread_mutex_unlock(&srv->srv_blob.mtx);

	while (pthread_mutex_trylock(&srv->srv_blob.mtx) == EBUSY);
pthread_mutex_destroy(&srv->srv_blob.mtx);	pthread_mutex_destroy(&srv->srv_blob.mtx);
}	}

Line 439 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)	Line 444 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++)	for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++)
if (!c->cli_sa.sa_family)	if (!c->cli_sa.sa_family)
break;	break;
if (c && c->cli_sa.sa_family && c->cli_parent) {	if (i >= srv->srv_numcli) {
usleep(1000000);	usleep(1000000);
continue;	continue;
}	}
Line 575 rpc_srv_initServer(u_int regProgID, u_int regProcID, i	Line 580 rpc_srv_initServer(u_int regProgID, u_int regProcID, i
} else	} else
memset(srv->srv_clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));	memset(srv->srv_clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));

	pthread_mutex_init(&srv->srv_mtx, NULL);

rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);	rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);
rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 0);	rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 0);
rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 0);	rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 0);
rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 0);	rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 0);

pthread_mutex_init(&srv->srv_mtx, NULL);
return srv;	return srv;
}	}

Line 610 rpc_srv_endServer(rpc_srv_t * __restrict srv)	Line 615 rpc_srv_endServer(rpc_srv_t * __restrict srv)

if (srv->srv_clients) {	if (srv->srv_clients) {
free(srv->srv_clients);	free(srv->srv_clients);
	srv->srv_clients = NULL;
srv->srv_numcli = 0;	srv->srv_numcli = 0;
}	}

Line 620 rpc_srv_endServer(rpc_srv_t * __restrict srv)	Line 626 rpc_srv_endServer(rpc_srv_t * __restrict srv)
}	}
pthread_mutex_unlock(&srv->srv_mtx);	pthread_mutex_unlock(&srv->srv_mtx);

	while (pthread_mutex_trylock(&srv->srv_mtx) == EBUSY);
pthread_mutex_destroy(&srv->srv_mtx);	pthread_mutex_destroy(&srv->srv_mtx);

free(srv);	free(srv);
Line 655 rpc_srv_execServer(rpc_srv_t * __restrict srv)	Line 662 rpc_srv_execServer(rpc_srv_t * __restrict srv)
for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++)	for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++)
if (!c->cli_sa.sa_family)	if (!c->cli_sa.sa_family)
break;	break;
if (c && c->cli_sa.sa_family && c->cli_parent) {	if (i >= srv->srv_numcli) {
usleep(1000000);	usleep(1000000);
continue;	continue;
}	}

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

Removed from v.1.1.1.1.2.12
changed lines
	Added in v.1.1.1.1.2.21