Return to tsrv2.c CVS log

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

Annotation of libaitrpc/example/tsrv2.c, revision 1.3.8.1

1.2       misho       1: #include <stdio.h>
                      2: #include <pthread.h>
1.3       misho       3: #include <string.h>
                      4: #include <errno.h>
1.2       misho       5: #include <aitrpc.h>
                      6: #include "rc.h"
                      7: 
                      8: 
                      9: rpc_srv_t *srv;
                     10: 
                     11: 
                     12: int aaa(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                     13: {
                     14: //     rpc_blob_t *b;
                     15: 
                     16:        RPC_CALLBACK_CHECK_INPUT(cli);
                     17: 
                     18:        printf("%s(%d): Piuk! aaaaaa\n", __func__, __LINE__);
                     19: 
                     20:        /*
                     21:        b = rpc_srv_registerBLOB(f->func_parent, BUFSIZ);
                     22:        if (!b)
                     23:                return -1;
                     24:        if (rpc_srv_blobMap(f->func_parent, b) == -1) {
                     25:                rpc_srv_blobFree(f->func_parent, b);
                     26:                return -1;
                     27:        }
                     28: 
                     29:        memset(b->blob_data, 0, b->blob_len);
                     30:        strcpy(b->blob_data, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa dsfsfsfnskjfnk\n");
                     31: 
                     32:        rpc_srv_blobUnmap(b);
                     33:        */
                     34: 
                     35:        RPC_SET_ERRNO(rpc, EAGAIN);
                     36:        return 0;
                     37: }
                     38: 
                     39: int BBB(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                     40: {
                     41:        ait_val_t *v;
                     42:        rpc_blob_t *b;
                     43:        rpc_srv_t *s;
                     44: 
                     45:        RPC_CALLBACK_CHECK_INPUT(cli);
                     46:        s = RPC_SRV_SERVER(cli);
                     47: 
                     48:        printf("%s(%d): Piuk! %d %s %X\n", __func__, __LINE__, 
                     49:                        AIT_GET_I32(array(iv, 0, ait_val_t*)), AIT_GET_STR(array(iv, 1, ait_val_t*)), 
                     50:                        AIT_GET_BLOB(array(iv, 2, ait_val_t*)));
                     51: 
                     52:        // input blob object
                     53:        if (!(b = rpc_srv_getBLOB(s, AIT_GET_BLOB(array(iv, 2, ait_val_t*)))))
                     54:                return -1;
                     55:        if (rpc_srv_blobMap(s, b) == -1) {
                     56:                rpc_srv_blobFree(s, b);
                     57:                return -1;
                     58:        }
                     59:        printf("VAR=%X(%d):: %s\n", b->blob_var, b->blob_len, b->blob_data);
                     60:        rpc_srv_blobUnmap(b);
                     61:        rpc_srv_unregisterBLOB(s, AIT_GET_BLOB(array(iv, 2, ait_val_t*)));
                     62: 
                     63: 
                     64:        AIT_SET_BUF(ait_getVars(&RPC_RETVARS(cli), 0), "00!oo", 6);
                     65:        AIT_SET_I8(ait_getVars(&RPC_RETVARS(cli), 1), 65);
                     66:        AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 2), "Oho boho i cheburashka");
                     67: 
                     68:        // return blob object
                     69:        b = rpc_srv_registerBLOB(s, 128, 0);
                     70:        if (!b)
                     71:                return -1;
                     72:        else
                     73:                AIT_SET_BLOB2(ait_getVars(&RPC_RETVARS(cli), 3), b);
                     74: 
                     75:        printf("data=%p blen=%d\n", b->blob_data, b->blob_len);
                     76:        memset(b->blob_data, 0, b->blob_len);
                     77:        strcpy(b->blob_data, "Hello Worldzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz mzdnfdskf\naddfs\n");
                     78: 
                     79:        rpc_srv_blobUnmap(b);
                     80:        return 33;
                     81: }
                     82: 
                     83: int xxx(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                     84: {
                     85:        ait_val_t *v;
                     86: 
                     87:        RPC_CALLBACK_CHECK_INPUT(cli);
                     88: 
                     89:        printf("iv_s=%d\n", array_Size(iv));
                     90:        printf("%s(%d): Piuk! --- %s\n", __func__, __LINE__, AIT_GET_BUF(array(iv, 0, ait_val_t*)));
                     91: 
                     92:        v = ait_getVars(&RPC_RETVARS(cli), 0);
                     93:        AIT_SET_DATA(v, "00!oo", 6);
                     94:        array_Set(RPC_RETVARS(cli), 0, v);
                     95:        AIT_SET_I8(ait_getVars(&RPC_RETVARS(cli), 1), 65);
                     96:        return 111;
                     97: }
                     98: 
                     99: int xYz(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                    100: {
                    101:        return 0;
                    102: }
                    103: 
                    104: int big(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                    105: {
                    106:        RPC_CALLBACK_CHECK_INPUT(cli);
                    107:        ait_val_t *v;
                    108: 
                    109:        printf("Ok lets fun... %d\n", array_Size(iv));
                    110: 
                    111:        v = ait_getVars(&RPC_RETVARS(cli), 0);
                    112:        AIT_SET_BUFSIZ(v, '*', 5000000);
                    113:        return 0;
                    114: }
                    115: 
                    116: int main(int argc, char **argv)
                    117: {
                    118:        rpc_func_t *f;
                    119:        int ret;
                    120: 
                    121:        srv = rpc_srv_initServer2(2, 2, 1024 * 10, NULL);
                    122:        if (!srv) {
                    123:                printf("error:: errno=%d %s\n", rpc_GetErrno(), rpc_GetError());
                    124:                return 1;
                    125:        }
                    126: 
                    127:        rpc_srv_registerCall(srv, RC_aaa, aaa);
                    128:        rpc_srv_registerCall(srv, RC_BBB, BBB);
                    129:        rpc_srv_registerCall(srv, 3, NULL);
                    130:        rpc_srv_registerCall(srv, RC_xYz, xYz);
                    131:        rpc_srv_registerCall(srv, RC_xxx, xxx);
                    132:        rpc_srv_registerCall(srv, RC_big, big);
                    133: 
                    134:        rpc_srv_unregisterCall(srv, 4);
                    135: 
                    136:        rpc_register_srvServices(srv);
                    137: 
1.3.8.1 ! misho     138:        rpc_srv_DispatchSignal(srv, 42);
1.2       misho     139:        rpc_srv_loopServer(srv);
1.3.8.1 ! misho     140:        rpc_srv_DispatchSignal(srv, 0);
1.2       misho     141:        rpc_srv_endServer(&srv);
                    142:        return 0;
                    143: }