version 1.1, 2010/06/18 01:48:06
|
version 1.18, 2015/07/02 22:28:13
|
Line 1
|
Line 1
|
#include <stdio.h> |
#include <stdio.h> |
|
#include <string.h> |
|
#include <errno.h> |
|
#include <pthread.h> |
#include <aitrpc.h> |
#include <aitrpc.h> |
|
#include "rc.h" |
|
|
|
|
int aaa(void * const data, rpc_func_t *f, int in, rpc_val_t *iv) | rpc_srv_t *srv; |
| |
| |
| int aaa(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv) |
{ |
{ |
RPC_CALLBACK_CHECK_ARGS(f, in); | // rpc_blob_t *b; |
|
|
printf("%s(%d): Piuk! %s\n", __func__, __LINE__, f->func_name); | RPC_CALLBACK_CHECK_INPUT(cli); |
| |
| printf("%s(%d): Piuk! aaaaaa\n", __func__, __LINE__); |
| |
| /* |
| b = rpc_srv_registerBLOB(f->func_parent, BUFSIZ); |
| if (!b) |
| return -1; |
| if (rpc_srv_blobMap(f->func_parent, b) == -1) { |
| rpc_srv_blobFree(f->func_parent, b); |
| return -1; |
| } |
| |
| memset(b->blob_data, 0, b->blob_len); |
| strcpy(b->blob_data, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa dsfsfsfnskjfnk\n"); |
| |
| rpc_srv_blobUnmap(b); |
| */ |
| |
| RPC_SET_ERRNO(rpc, EAGAIN); |
return 0; |
return 0; |
} |
} |
|
|
int BBB(void * const data, rpc_func_t *f, int in, rpc_val_t *iv) | int BBB(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv) |
{ |
{ |
rpc_val_t *v; | ait_val_t *v; |
| rpc_blob_t *b; |
| rpc_srv_t *s; |
|
|
RPC_CALLBACK_CHECK_ARGS(f, in); | RPC_CALLBACK_CHECK_INPUT(cli); |
| s = RPC_SRV_SERVER(cli); |
|
|
printf("%s(%d): Piuk! %s %d %s %d\n", __func__, __LINE__, f->func_name, | printf("%s(%d): Piuk! %d %s %X\n", __func__, __LINE__, |
RPC_GET_I32(&iv[0]), RPC_GET_STR(&iv[1]), RPC_GET_U16(&iv[2])); | AIT_GET_I32(array(iv, 0, ait_val_t*)), AIT_GET_STR(array(iv, 1, ait_val_t*)), |
| AIT_GET_BLOB(array(iv, 2, ait_val_t*))); |
|
|
rpc_srv_declValsCall(f, 3); | // input blob object |
rpc_srv_getValsCall(f, &v); | if (!(b = rpc_srv_getBLOB(s, AIT_GET_BLOB(array(iv, 2, ait_val_t*))))) |
RPC_SET_BUF(&v[0], "00!oo", 6); | return -1; |
RPC_SET_I8(&v[1], 65); | if (rpc_srv_blobMap(s, b) == -1) { |
RPC_SET_STR(&v[2], "Oho boho i cheburashka"); | rpc_srv_blobFree(s, b); |
| return -1; |
| } |
| printf("VAR=%X(%d):: %s\n", b->blob_var, b->blob_len, b->blob_data); |
| rpc_srv_blobUnmap(b); |
| rpc_srv_unregisterBLOB(s, AIT_GET_BLOB(array(iv, 2, ait_val_t*))); |
| |
| |
| AIT_SET_BUF(ait_getVars(&RPC_RETVARS(cli), 0), "00!oo", 6); |
| AIT_SET_I8(ait_getVars(&RPC_RETVARS(cli), 1), 65); |
| AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 2), "Oho boho i cheburashka"); |
| |
| // return blob object |
| b = rpc_srv_registerBLOB(s, 128, 0); |
| if (!b) |
| return -1; |
| else |
| AIT_SET_BLOB2(ait_getVars(&RPC_RETVARS(cli), 3), b); |
| |
| printf("data=%p blen=%d\n", b->blob_data, b->blob_len); |
| memset(b->blob_data, 0, b->blob_len); |
| strcpy(b->blob_data, "Hello Worldzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz mzdnfdskf\naddfs\n"); |
| |
| rpc_srv_blobUnmap(b); |
return 33; |
return 33; |
} |
} |
|
|
int main() | int xxx(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv) |
{ |
{ |
rpc_srv_t *srv; | ait_val_t *v; |
| |
| RPC_CALLBACK_CHECK_INPUT(cli); |
| |
| printf("iv_s=%d\n", array_Size(iv)); |
| printf("%s(%d): Piuk! --- %s\n", __func__, __LINE__, AIT_GET_BUF(array(iv, 0, ait_val_t*))); |
| |
| v = ait_getVars(&RPC_RETVARS(cli), 0); |
| AIT_SET_DATA(v, "00!oo", 6); |
| array_Set(RPC_RETVARS(cli), 0, v); |
| AIT_SET_I8(ait_getVars(&RPC_RETVARS(cli), 1), 65); |
| return 111; |
| } |
| |
| int xYz(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv) |
| { |
| return 0; |
| } |
| |
| int big(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv) |
| { |
| ait_val_t *v; |
| |
| RPC_CALLBACK_CHECK_INPUT(cli); |
| |
| printf("Ok lets fun... %d\n", array_Size(iv)); |
| |
| mpool_dump(NULL, ">>> %s(%d) ", __func__, __LINE__); |
| v = ait_getVars(&RPC_RETVARS(cli), 0); |
| AIT_SET_BUFSIZ(v, '*', AIT_GET_I32(array(iv, 0, ait_val_t*))); |
| mpool_dump(NULL, ">>> %s(%d) ", __func__, __LINE__); |
| return 0; |
| } |
| |
| int main(int argc, char **argv) |
| { |
rpc_func_t *f; |
rpc_func_t *f; |
|
int ret; |
|
|
srv = rpc_srv_initServer(100, 2, 1, 2, "0.0.0.0", 11111); | if (argc > 1) { |
| if (argc > 2) |
| srv = rpc_srv_initServer(2, 3, 1024 * 10, "0.0.0.0", 0, SOCK_RAW); |
| else |
| srv = rpc_srv_initServer(2, 5, 1024 * 10, "0.0.0.0", 11111, SOCK_DGRAM); |
| } else |
| srv = rpc_srv_initServer(2, 2, 1024 * 10, "0.0.0.0", 11111, 0); |
if (!srv) { |
if (!srv) { |
printf("error:: errno=%d %s\n", rpc_GetErrno(), rpc_GetError()); |
printf("error:: errno=%d %s\n", rpc_GetErrno(), rpc_GetError()); |
return 1; |
return 1; |
} |
} |
|
|
rpc_srv_registerCall(srv, NULL, "aaa", 0); | if (rpc_srv_initBLOBServer(srv, 0, "/tmp")) { |
rpc_srv_registerCall(srv, NULL, "BBB", 3); | printf("error:: errno=%d %s\n", rpc_GetErrno(), rpc_GetError()); |
rpc_srv_registerCall(srv, NULL, "dummy", 1); | return 1; |
rpc_srv_registerCall(srv, NULL, "xYz", 2); | } |
|
|
rpc_srv_unregisterCall(srv, NULL, "dummy"); | rpc_srv_registerCall(srv, RC_aaa, aaa); |
| rpc_srv_registerCall(srv, RC_BBB, BBB); |
| rpc_srv_registerCall(srv, 3, NULL); |
| rpc_srv_registerCall(srv, RC_xYz, xYz); |
| rpc_srv_registerCall(srv, RC_xxx, xxx); |
| rpc_srv_registerCall(srv, RC_big, big); |
|
|
for (f = srv->srv_funcs; f; f = f->func_next) | rpc_srv_unregisterCall(srv, 4); |
printf("func::name=%s args=%d\n", f->func_name, f->func_args); | |
|
|
switch (fork()) { | rpc_register_srvServices(srv); |
case -1: | rpc_register_blobServices(srv); |
return 1; | |
case 0: | |
setsid(); | |
|
|
if (rpc_srv_execServer(srv) == -1) { | mpool_dump(NULL, NULL); |
printf("error:: errno=%d %s\n", rpc_GetErrno(), rpc_GetError()); | |
return 2; | |
} | |
break; | |
} | |
|
|
rpc_srv_endServer(srv); | rpc_srv_execBLOBServer(srv); |
| rpc_srv_loopServer(srv); |
| |
| rpc_srv_endBLOBServer(srv); |
| rpc_srv_endServer(&srv); |
| mpool_dump(NULL, NULL); |
return 0; |
return 0; |
} |
} |