version 1.4.2.6, 2011/09/01 14:28:41
|
version 1.4.2.9, 2011/09/03 12:58:49
|
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 (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_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 |
Line 123 rpc_srv_dispatchCall(void *arg)
|
Line 123 rpc_srv_dispatchCall(void *arg)
|
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, rpc->call_tag, 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 157 makeReply:
|
Line 157 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 173 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 240 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 284 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 300 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 310 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 467 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 467 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 727 rpc_srv_endServer(rpc_srv_t * __restrict srv)
|
Line 727 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 745 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
Line 745 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n"); |
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n"); |
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; |