version 1.4.2.6, 2011/09/01 14:28:41
|
version 1.5.2.2, 2011/09/07 09:10:55
|
Line 97 rpc_srv_dispatchCall(void *arg)
|
Line 97 rpc_srv_dispatchCall(void *arg)
|
break; |
break; |
} |
} |
if (ret < sizeof(struct tagRPCCall)) { |
if (ret < sizeof(struct tagRPCCall)) { |
rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n"); | rpc_SetErr(ERPCMISMATCH, "Error:: too short RPC packet ...\n"); |
ret = -4; |
ret = -4; |
break; |
break; |
} else |
} else |
rpc = (struct tagRPCCall*) buf; |
rpc = (struct tagRPCCall*) buf; |
/* check RPC packet session info */ |
/* check RPC packet session info */ |
if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) { | if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) { |
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n"); | rpc_SetErr(ERPCMISMATCH, "Error:: get invalid RPC session ...\n"); |
ret = -5; |
ret = -5; |
goto makeReply; |
goto makeReply; |
} else |
} else |
Limit = sizeof(struct tagRPCCall); |
Limit = sizeof(struct tagRPCCall); |
|
|
/* RPC is OK! Go decapsulate variables ... */ |
/* RPC is OK! Go decapsulate variables ... */ |
if (rpc->call_argc) { | if (ntohs(rpc->call_argc)) { |
arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, rpc->call_argc, 1); | arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, |
| ntohs(rpc->call_argc), 1); |
if (!arr) { |
if (!arr) { |
ret = -5; |
ret = -5; |
goto makeReply; |
goto makeReply; |
} |
} |
} | } else |
| arr = NULL; |
|
|
/* execute call */ |
/* execute call */ |
argc = 0; |
argc = 0; |
memcpy(&ses, &rpc->call_session, sizeof ses); |
memcpy(&ses, &rpc->call_session, sizeof ses); |
if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) { | if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash)))) { |
rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n"); | rpc_SetErr(EPROGUNAVAIL, "Error:: call not found into RPC server ...\n"); |
ret = -6; |
ret = -6; |
} else |
} else |
if ((ret = rpc_srv_execCall(f, rpc, arr)) == -1) |
if ((ret = rpc_srv_execCall(f, rpc, arr)) == -1) |
Line 147 makeReply:
|
Line 149 makeReply:
|
memcpy(&rrpc->ret_session, &ses, sizeof(rpc_sess_t)); |
memcpy(&rrpc->ret_session, &ses, sizeof(rpc_sess_t)); |
rrpc->ret_tag = rpc->call_tag; |
rrpc->ret_tag = rpc->call_tag; |
rrpc->ret_hash = rpc->call_hash; |
rrpc->ret_hash = rpc->call_hash; |
rrpc->ret_errno = rpc_Errno; | rrpc->ret_errno = htonl(rpc_Errno); |
rrpc->ret_retcode = ret; | rrpc->ret_retcode = htonl(ret); |
rrpc->ret_argc = argc; | rrpc->ret_argc = htons(argc); |
|
|
if (argc && arr) { |
if (argc && arr) { |
/* Go Encapsulate variables ... */ |
/* Go Encapsulate variables ... */ |
Line 157 makeReply:
|
Line 159 makeReply:
|
rpc_srv_freeVals(f); |
rpc_srv_freeVals(f); |
argc = 0; |
argc = 0; |
ret = -7; |
ret = -7; |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n"); | rpc_SetErr(EBADRPC, "Error:: in prepare RPC packet values (-7) ...\n"); |
goto makeReply; |
goto makeReply; |
} else { |
} else { |
Limit += i; |
Limit += i; |
Line 173 makeReply:
|
Line 175 makeReply:
|
break; |
break; |
} |
} |
if (ret != Limit) { |
if (ret != Limit) { |
rpc_SetErr(ECANCELED, "Error:: in send RPC request, should be send %d bytes, " | rpc_SetErr(EPROCUNAVAIL, "Error:: in send RPC request, should be send %d bytes, " |
"really is %d\n", Limit, ret); |
"really is %d\n", Limit, ret); |
ret = -9; |
ret = -9; |
break; |
break; |
Line 240 rpc_srv_dispatchVars(void *arg)
|
Line 242 rpc_srv_dispatchVars(void *arg)
|
break; |
break; |
} |
} |
if (ret < sizeof(struct tagBLOBHdr)) { |
if (ret < sizeof(struct tagBLOBHdr)) { |
rpc_SetErr(EMSGSIZE, "Error:: too short BLOB packet ...\n"); | rpc_SetErr(ERPCMISMATCH, "Error:: too short BLOB packet ...\n"); |
ret = -4; |
ret = -4; |
break; |
break; |
} else |
} else |
Line 284 rpc_srv_dispatchVars(void *arg)
|
Line 286 rpc_srv_dispatchVars(void *arg)
|
ret = -7; |
ret = -7; |
break; |
break; |
default: |
default: |
rpc_SetErr(EINVAL, "Error:: unsupported BLOB command (%d)...\n", | rpc_SetErr(EPROCUNAVAIL, "Error:: unsupported BLOB command (%d)...\n", |
blob->hdr_cmd); |
blob->hdr_cmd); |
ret = -7; |
ret = -7; |
} |
} |
Line 300 makeReply:
|
Line 302 makeReply:
|
break; |
break; |
} |
} |
if (ret != sizeof buf) { |
if (ret != sizeof buf) { |
rpc_SetErr(ECANCELED, "Error:: in send BLOB reply, should be send %d bytes, " | rpc_SetErr(EPROCUNAVAIL, "Error:: in send BLOB reply, should be send %d bytes, " |
"really is %d\n", sizeof buf, ret); |
"really is %d\n", sizeof buf, ret); |
ret = -9; |
ret = -9; |
break; |
break; |
Line 310 makeReply:
|
Line 312 makeReply:
|
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(c->cli_sock); |
close(c->cli_sock); |
memset(c, 0, sizeof(rpc_cli_t)); |
memset(c, 0, sizeof(rpc_cli_t)); |
return (void*) (long)ret; | return (void*) ((long)ret); |
} |
} |
|
|
// ------------------------------------------------- |
// ------------------------------------------------- |
Line 448 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 450 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
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); |
|
|
|
pthread_mutex_lock(&srv->srv_blob.mtx); |
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; |
srv->srv_blob.clients = NULL; |
} |
} |
|
|
/* detach blobs */ |
/* detach blobs */ |
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); |
rpc_srv_blobFree(srv, f); |
Line 467 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 469 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
} |
} |
|
|
/* |
/* |
* rpc_srv_execBLOBServer() Execute Main BLOB server loop and wait for clients requests | * rpc_srv_loopBLOB() Execute Main BLOB server loop and wait for clients requests |
* @srv = RPC Server instance |
* @srv = RPC Server instance |
* return: -1 error or 0 ok, infinite loop ... |
* return: -1 error or 0 ok, infinite loop ... |
*/ |
*/ |
int |
int |
rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) | rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) |
{ |
{ |
socklen_t salen = sizeof(struct sockaddr); |
socklen_t salen = sizeof(struct sockaddr); |
register int i; |
register int i; |
Line 496 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
Line 498 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
if (!c->cli_sa.sa_family) |
if (!c->cli_sa.sa_family) |
break; |
break; |
if (i >= srv->srv_numcli) { |
if (i >= srv->srv_numcli) { |
usleep(1000000); |
|
#ifdef HAVE_PTHREAD_YIELD |
#ifdef HAVE_PTHREAD_YIELD |
pthread_yield(); |
pthread_yield(); |
|
#else |
|
usleep(1000000); |
#endif |
#endif |
continue; |
continue; |
} |
} |
Line 528 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
Line 531 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
pthread_detach(c->cli_tid); |
pthread_detach(c->cli_tid); |
} |
} |
|
|
srv->srv_blob.state = disable; | srv->srv_blob.state = kill; |
|
|
return 0; |
return 0; |
} |
} |
Line 727 rpc_srv_endServer(rpc_srv_t * __restrict srv)
|
Line 730 rpc_srv_endServer(rpc_srv_t * __restrict srv)
|
} |
} |
|
|
/* |
/* |
* rpc_srv_execServer() Execute Main server loop and wait for clients requests | * rpc_srv_loopServer() Execute Main server loop and wait for clients requests |
* @srv = RPC Server instance |
* @srv = RPC Server instance |
* return: -1 error or 0 ok, infinite loop ... |
* return: -1 error or 0 ok, infinite loop ... |
*/ |
*/ |
int |
int |
rpc_srv_execServer(rpc_srv_t * __restrict srv) | rpc_srv_loopServer(rpc_srv_t * __restrict srv) |
{ |
{ |
socklen_t salen = sizeof(struct sockaddr); |
socklen_t salen = sizeof(struct sockaddr); |
register int i; |
register int i; |
Line 746 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
Line 749 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
return -1; |
return -1; |
} |
} |
|
|
|
/* activate BLOB server worker if srv->srv_blob.state == enable */ |
|
rpc_srv_execBLOBServer(srv); |
|
|
if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) { |
if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
Line 756 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
Line 762 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
if (!c->cli_sa.sa_family) |
if (!c->cli_sa.sa_family) |
break; |
break; |
if (i >= srv->srv_numcli) { |
if (i >= srv->srv_numcli) { |
usleep(1000000); |
|
#ifdef HAVE_PTHREAD_YIELD |
#ifdef HAVE_PTHREAD_YIELD |
pthread_yield(); |
pthread_yield(); |
|
#else |
|
usleep(1000000); |
#endif |
#endif |
continue; |
continue; |
} |
} |
Line 821 rpc_srv_execCall(rpc_func_t * __restrict call, struct
|
Line 828 rpc_srv_execCall(rpc_func_t * __restrict call, struct
|
|
|
func = dlsym(dl, (char*) call->func_name); |
func = dlsym(dl, (char*) call->func_name); |
if (func) |
if (func) |
ret = func(call, rpc->call_argc, args); | ret = func(call, ntohs(rpc->call_argc), args); |
else { |
else { |
rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror()); |
rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror()); |
ret = -1; |
ret = -1; |