version 1.1.1.1.2.5, 2010/06/23 15:07:15
|
version 1.1.1.1.2.10, 2010/06/24 13:58:17
|
Line 12
|
Line 12
|
static void * |
static void * |
rpc_srv_dispatchCall(void *arg) |
rpc_srv_dispatchCall(void *arg) |
{ |
{ |
rpc_cli_t cli, *c = arg; | rpc_cli_t *c = arg; |
rpc_srv_t *s; |
rpc_srv_t *s; |
rpc_val_t *vals, *v = NULL; |
rpc_val_t *vals, *v = NULL; |
rpc_func_t *f; |
rpc_func_t *f; |
Line 74 rpc_srv_dispatchCall(void *arg)
|
Line 74 rpc_srv_dispatchCall(void *arg)
|
v[i].val.string = (int8_t*) data; |
v[i].val.string = (int8_t*) data; |
data += v[i].val_len + 1; |
data += v[i].val_len + 1; |
break; |
break; |
case blob: |
|
rpc_srv_getBLOBVar(&v[i], data); |
|
data += sizeof(rpc_cli_t); |
|
break; |
|
default: |
default: |
break; |
break; |
} |
} |
Line 135 rpc_srv_dispatchCall(void *arg)
|
Line 131 rpc_srv_dispatchCall(void *arg)
|
data += vals[i].val_len + 1; |
data += vals[i].val_len + 1; |
Limit += vals[i].val_len + 1; |
Limit += vals[i].val_len + 1; |
break; |
break; |
case blob: |
|
if (ret || Limit + sizeof(rpc_cli_t) > BUFSIZ) { |
|
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); |
|
rrpc.ret_retcode = ret = -7; |
|
rrpc.ret_argc = 0; |
|
break; |
|
} |
|
|
|
memcpy(data, &cli, sizeof(rpc_cli_t)); |
|
data += sizeof(rpc_cli_t); |
|
Limit += sizeof(rpc_cli_t); |
|
|
|
rpc_srv_setBLOBVar(&vals[i], &cli); |
|
break; |
|
default: |
default: |
break; |
break; |
} |
} |
Line 185 rpc_srv_dispatchVars(void *arg)
|
Line 167 rpc_srv_dispatchVars(void *arg)
|
rpc_blob_t *b; |
rpc_blob_t *b; |
int cx, ret; |
int cx, ret; |
fd_set fds; |
fd_set fds; |
u_char buf[BLOBSIZ]; | u_char buf[sizeof(struct tagBLOBHdr)]; |
struct tagBLOBHdr *blob; |
struct tagBLOBHdr *blob; |
|
|
if (!arg) { |
if (!arg) { |
Line 196 rpc_srv_dispatchVars(void *arg)
|
Line 178 rpc_srv_dispatchVars(void *arg)
|
|
|
cx = -1; |
cx = -1; |
do { |
do { |
cx++; |
|
|
|
FD_ZERO(&fds); |
FD_ZERO(&fds); |
FD_SET(c->cli_sock, &fds); |
FD_SET(c->cli_sock, &fds); |
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 |
memset(buf, 0, BLOBSIZ); | cx++; |
if ((ret = recv(c->cli_sock, buf, BLOBSIZ, 0)) == -1) { | memset(buf, 0, sizeof buf); |
| if ((ret = recv(c->cli_sock, buf, sizeof buf, 0)) == -1) { |
LOGERR; |
LOGERR; |
ret = -3; |
ret = -3; |
break; |
break; |
} |
} |
if (!ret) { // receive EOF | if (!ret || s->srv_blob.state == disable) { // receive EOF or disable service |
ret = 0; |
ret = 0; |
break; |
break; |
} |
} |
Line 227 rpc_srv_dispatchVars(void *arg)
|
Line 208 rpc_srv_dispatchVars(void *arg)
|
ret = -5; |
ret = -5; |
break; |
break; |
} |
} |
// Go to decapsulate packet ... | // Go to proceed packet ... |
if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) { | |
rpc_SetErr(EINVAL, "Error:: var (%x) not found into BLOB server ...\n", blob->hdr_var); | |
ret = -6; | |
break; | |
} | |
switch (blob->hdr_cmd) { |
switch (blob->hdr_cmd) { |
case get: |
case get: |
ret = rpc_srv_sendBLOB(c, b); | if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) { |
| rpc_SetErr(EINVAL, "Error:: var (%x) not found into BLOB server ...\n", |
| blob->hdr_var); |
| ret = -6; |
| break; |
| } |
| |
| if (rpc_srv_blobMap(s, b) != -1) { |
| ret = rpc_srv_sendBLOB(c, b); |
| rpc_srv_blobUnmap(b); |
| } else |
| ret = -7; |
break; |
break; |
case set: |
case set: |
ret = rpc_srv_recvBLOB(c, b); | if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) { |
| // set new BLOB variable for reply :) |
| blob->hdr_var = b->blob_var; |
| |
| ret = rpc_srv_recvBLOB(c, b); |
| rpc_srv_blobUnmap(b); |
| } else |
| ret = -7; |
break; |
break; |
case unset: |
case unset: |
ret = rpc_srv_freeBLOB(b); | ret = rpc_srv_unregisterBLOB(s, blob->hdr_var); |
| if (ret == -1) |
| ret = -7; |
break; |
break; |
default: |
default: |
rpc_SetErr(EINVAL, "Error:: unsupported BLOB command (%d)...\n", |
rpc_SetErr(EINVAL, "Error:: unsupported BLOB command (%d)...\n", |
blob->hdr_cmd); |
blob->hdr_cmd); |
ret -7; | ret = -7; |
} |
} |
|
|
|
// Replay to client! |
|
blob->hdr_cmd = ret < 0 ? error : ok; |
|
blob->hdr_seq = ret; |
|
if ((ret = send(c->cli_sock, buf, sizeof buf, 0)) == -1) { |
|
LOGERR; |
|
ret = -8; |
|
break; |
|
} |
|
if (ret != sizeof buf) { |
|
rpc_SetErr(EBADMSG, "Error:: in send BLOB reply, should be send %d bytes, " |
|
"really is %d\n", sizeof buf, ret); |
|
ret = -9; |
|
break; |
|
} |
} while (ret > -1); |
} while (ret > -1); |
|
|
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
Line 355 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 366 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
return; |
return; |
} else |
} else |
srv->srv_blob.state = disable; |
srv->srv_blob.state = disable; |
|
|
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN); |
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS); |
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS); |
|
|
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) |