Annotation of libaitrpc/src/builtin.c, revision 1.10.2.1

1.1       misho       1: /*************************************************************************
                      2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
                      3: *  by Michael Pounov <misho@openbsd-bg.org>
                      4: *
                      5: * $Author: misho $
1.10.2.1! misho       6: * $Id: builtin.c,v 1.10 2012/11/13 09:22:10 misho Exp $
1.1       misho       7: *
1.2       misho       8: **************************************************************************
                      9: The ELWIX and AITNET software is distributed under the following
                     10: terms:
                     11: 
                     12: All of the documentation and software included in the ELWIX and AITNET
                     13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
                     14: 
1.6       misho      15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
1.2       misho      16:        by Michael Pounov <misho@elwix.org>.  All rights reserved.
                     17: 
                     18: Redistribution and use in source and binary forms, with or without
                     19: modification, are permitted provided that the following conditions
                     20: are met:
                     21: 1. Redistributions of source code must retain the above copyright
                     22:    notice, this list of conditions and the following disclaimer.
                     23: 2. Redistributions in binary form must reproduce the above copyright
                     24:    notice, this list of conditions and the following disclaimer in the
                     25:    documentation and/or other materials provided with the distribution.
                     26: 3. All advertising materials mentioning features or use of this software
                     27:    must display the following acknowledgement:
                     28: This product includes software developed by Michael Pounov <misho@elwix.org>
                     29: ELWIX - Embedded LightWeight unIX and its contributors.
                     30: 4. Neither the name of AITNET nor the names of its contributors
                     31:    may be used to endorse or promote products derived from this software
                     32:    without specific prior written permission.
                     33: 
                     34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
                     35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     44: SUCH DAMAGE.
                     45: */
1.1       misho      46: #include "global.h"
                     47: 
                     48: 
                     49: /* builtin RPC server functions */
                     50: 
1.8       misho      51: static int
                     52: rpcServerClients(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.1       misho      53: {
1.2       misho      54:        rpc_srv_t *srv;
1.8       misho      55:        rpc_cli_t *c;
1.1       misho      56:        register int i;
1.4       misho      57:        int len;
1.3       misho      58:        const char *str = NULL;
1.8       misho      59:        char *val;
                     60:        ait_val_t v;
1.2       misho      61: 
1.8       misho      62:        RPC_CALLBACK_CHECK_INPUT(cli);
                     63:        srv = RPC_SRV_SERVER(cli);
1.4       misho      64: 
1.8       misho      65:        len = io_arraySize(srv->srv_clients) * STRSIZ;
1.9       misho      66:        if (!(val = io_malloc(len))) {
1.4       misho      67:                LOGERR;
1.1       misho      68:                return -1;
1.4       misho      69:        } else
                     70:                memset(val, 0, len);
1.1       misho      71: 
1.8       misho      72:        for (i = 0; i < io_arraySize(srv->srv_clients); i++) {
                     73:                c = io_array(srv->srv_clients, i, rpc_cli_t*);
                     74:                if (!c)
1.1       misho      75:                        continue;
                     76: 
1.8       misho      77:                str = io_n2addr(&c->cli_sa, &v);
1.2       misho      78:                if (str)
1.4       misho      79:                        strlcat(val, (char*) str, len);
1.2       misho      80:                else
1.4       misho      81:                        strlcat(val, "0.0.0.0", len);
                     82:                strlcat(val, " ", len);
1.8       misho      83:                AIT_FREE_VAL(&v);
1.1       misho      84:        }
                     85: 
1.8       misho      86:        /* return values */
                     87:        AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);
1.9       misho      88:        io_free(val);
1.1       misho      89:        return 0;
                     90: }
                     91: 
1.8       misho      92: static int
                     93: rpcServerCalls(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.1       misho      94: {
1.2       misho      95:        rpc_srv_t *srv;
1.1       misho      96:        rpc_func_t *f;
1.8       misho      97:        register int i = 0;
1.4       misho      98:        int len;
                     99:        char *val, str[MAXPATHLEN];
1.1       misho     100: 
1.8       misho     101:        RPC_CALLBACK_CHECK_INPUT(cli);
                    102:        srv = RPC_SRV_SERVER(cli);
1.1       misho     103: 
1.10      misho     104:        SLIST_FOREACH(f, &srv->srv_funcs, func_next)
1.8       misho     105:                i++;
1.4       misho     106:        len = i * STRSIZ;
                    107: 
1.9       misho     108:        if (!(val = io_malloc(len))) {
1.4       misho     109:                LOGERR;
1.1       misho     110:                return -1;
1.4       misho     111:        } else
                    112:                memset(val, 0, len);
1.1       misho     113: 
1.10      misho     114:        SLIST_FOREACH(f, &srv->srv_funcs, func_next)
1.8       misho     115:                if (AIT_ADDR(&f->func_name)) {
1.3       misho     116:                        memset(str, 0, sizeof str);
1.8       misho     117:                        snprintf(str, sizeof str, "/%hu/0x%p; ", AIT_KEY(&f->func_name), 
                    118:                                        AIT_ADDR(&f->func_name));
1.4       misho     119:                        strlcat(val, str, len);
1.1       misho     120:                }
                    121: 
1.8       misho     122:        /* return variables */
                    123:        AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);
1.9       misho     124:        io_free(val);
1.1       misho     125:        return 0;
                    126: }
                    127: 
1.8       misho     128: static int
                    129: rpcServerSessions(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.1       misho     130: {
1.2       misho     131:        rpc_srv_t *srv;
1.1       misho     132: 
1.8       misho     133:        RPC_CALLBACK_CHECK_INPUT(cli);
                    134:        srv = RPC_SRV_SERVER(cli);
1.1       misho     135: 
1.8       misho     136:        AIT_SET_I32(io_getVars(&RPC_RETVARS(cli), 3), io_arraySize(srv->srv_clients));
                    137:        AIT_SET_U8(io_getVars(&RPC_RETVARS(cli), 0), srv->srv_session.sess_version);
                    138:        AIT_SET_U32(io_getVars(&RPC_RETVARS(cli), 1), srv->srv_session.sess_program);
                    139:        AIT_SET_U8(io_getVars(&RPC_RETVARS(cli), 2), srv->srv_session.sess_process);
1.1       misho     140: 
                    141:        return 0;
                    142: }
1.2       misho     143: 
1.8       misho     144: static int
                    145: rpcServerShutdown(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.2       misho     146: {
                    147:        rpc_srv_t *srv;
                    148: 
1.8       misho     149:        RPC_CALLBACK_CHECK_INPUT(cli);
                    150:        srv = RPC_SRV_SERVER(cli);
1.10.2.1! misho     151:        
        !           152:        rpc_freeCli(cli);
1.2       misho     153: 
1.8       misho     154:        srv->srv_kill = 1;
1.2       misho     155: 
                    156:        return 0;
                    157: }
                    158: 
1.8       misho     159: static int
                    160: rpcServerPing(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
                    161: {
                    162:        if (rpc->call_req.flags == RPC_REPLY)
                    163:                AIT_SET_U16(io_getVars(&RPC_RETVARS(cli), 0), ntohs(rpc->call_seq));
                    164:        return 0;
                    165: }
                    166: 
                    167: /* ---------------------------------------------------- */
1.2       misho     168: 
1.8       misho     169: static int
                    170: rpcBLOBServerShutdown(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.2       misho     171: {
                    172:        rpc_srv_t *srv;
                    173: 
1.8       misho     174:        RPC_CALLBACK_CHECK_INPUT(cli);
                    175:        srv = RPC_SRV_SERVER(cli);
1.2       misho     176: 
1.8       misho     177:        srv->srv_blob.kill = 1;
1.2       misho     178: 
                    179:        return 0;
                    180: }
                    181: 
1.8       misho     182: static int
                    183: rpcBLOBServerVars(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.2       misho     184: {
                    185:        rpc_srv_t *srv;
                    186:        rpc_blob_t *b;
1.8       misho     187:        register int i = 0;
1.4       misho     188:        char *val, str[64];
                    189:        int len;
1.2       misho     190: 
1.8       misho     191:        RPC_CALLBACK_CHECK_INPUT(cli);
                    192:        srv = RPC_SRV_SERVER(cli);
1.2       misho     193: 
1.8       misho     194:        if (srv->srv_blob.kill) {
                    195:                AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
1.4       misho     196:                return 1;
                    197:        }
                    198: 
1.8       misho     199:        TAILQ_FOREACH(b, &srv->srv_blob.blobs, blob_node)
                    200:                i++;
1.4       misho     201:        len = i * sizeof str;
                    202: 
                    203:        if (!len) {
1.8       misho     204:                AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), "");
1.2       misho     205:                return 0;
                    206:        }
                    207: 
1.9       misho     208:        if (!(val = io_malloc(len))) {
1.4       misho     209:                LOGERR;
                    210:                return -1;
                    211:        } else
                    212:                memset(val, 0, len);
                    213: 
1.8       misho     214:        TAILQ_FOREACH(b, &srv->srv_blob.blobs, blob_node) {
1.4       misho     215:                memset(str, 0, sizeof str);
                    216:                snprintf(str, sizeof str, "0x%0X(%lu)=%p ", b->blob_var, (u_long) b->blob_len, b->blob_data);
                    217:                strlcat(val, str, len);
                    218:        }
                    219: 
1.8       misho     220:        AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);
1.9       misho     221:        io_free(val);
1.2       misho     222:        return 0;
                    223: }
                    224: 
1.8       misho     225: static int
                    226: rpcBLOBServerClients(rpc_cli_t *cli, struct tagRPCCall *rpc, array_t *iv)
1.2       misho     227: {
                    228:        rpc_srv_t *srv;
1.8       misho     229:        rpc_cli_t *c;
1.2       misho     230:        register int i;
1.4       misho     231:        int len;
1.3       misho     232:        const char *str = NULL;
1.8       misho     233:        char *val;
                    234:        ait_val_t v;
1.2       misho     235: 
1.8       misho     236:        RPC_CALLBACK_CHECK_INPUT(cli);
                    237:        srv = RPC_SRV_SERVER(cli);
1.4       misho     238: 
1.8       misho     239:        if (srv->srv_blob.kill) {
                    240:                AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
1.4       misho     241:                return 1;
                    242:        }
                    243: 
1.8       misho     244:        len = io_arraySize(srv->srv_blob.clients) * STRSIZ;
1.9       misho     245:        if (!(val = io_malloc(len))) {
1.4       misho     246:                LOGERR;
1.2       misho     247:                return -1;
1.4       misho     248:        } else
                    249:                memset(val, 0, len);
1.2       misho     250: 
1.8       misho     251:        for (i = 0; i < io_arraySize(srv->srv_clients); i++) {
                    252:                c = io_array(srv->srv_blob.clients, i, rpc_cli_t*);
                    253:                if (!c)
1.2       misho     254:                        continue;
                    255: 
1.8       misho     256:                str = io_n2addr(&c->cli_sa, &v);
1.2       misho     257:                if (str)
1.4       misho     258:                        strlcat(val, (char*) str, len);
1.2       misho     259:                else
1.4       misho     260:                        strlcat(val, "0.0.0.0", len);
                    261:                strlcat(val, " ", len);
1.8       misho     262:                AIT_FREE_VAL(&v);
1.2       misho     263:        }
                    264: 
1.8       misho     265:        AIT_SET_STR(io_getVars(&RPC_RETVARS(cli), 0), val);
1.9       misho     266:        io_free(val);
1.2       misho     267:        return 0;
                    268: }
1.8       misho     269: 
                    270: /* ----------------------------------------------------------------- */
                    271: 
                    272: /*
                    273:  * rpc_register_srvPing() - Register ping service function
                    274:  *
                    275:  * @srv = RPC server instance
                    276:  * return: -1 error or 0 ok
                    277:  */
                    278: inline int
                    279: rpc_register_srvPing(rpc_srv_t * __restrict srv)
                    280: {
                    281:        if (!srv)
                    282:                return -1;
                    283: 
                    284:        if (rpc_srv_registerCall(srv, CALL_SRVPING, rpcServerPing) < 1)
                    285:                return -1;
                    286: 
                    287:        return 0;
                    288: }
                    289: 
                    290: /*
                    291:  * rpc_register_srvServices() - Register internal service functions
                    292:  *
                    293:  * @srv = RPC server instance
                    294:  * return: -1 error or 0 ok
                    295:  */
                    296: int
                    297: rpc_register_srvServices(rpc_srv_t * __restrict srv)
                    298: {
                    299:        if (!srv)
                    300:                return -1;
                    301: 
                    302:        if (rpc_srv_registerCall(srv, CALL_SRVSHUTDOWN, rpcServerShutdown) < 1)
                    303:                return -1;
                    304:        if (rpc_srv_registerCall(srv, CALL_SRVCLIENTS, rpcServerClients) < 1)
                    305:                return -1;
                    306:        if (rpc_srv_registerCall(srv, CALL_SRVSESSIONS, rpcServerSessions) < 1)
                    307:                return -1;
                    308:        if (rpc_srv_registerCall(srv, CALL_SRVCALLS, rpcServerCalls) < 1)
                    309:                return -1;
                    310: 
                    311:        return 0;
                    312: }
                    313: 
                    314: /*
                    315:  * rpc_register_blobServices() - Register internal service functions
                    316:  *
                    317:  * @srv = RPC server instance
                    318:  * return: -1 error or 0 ok
                    319:  */
                    320: int
                    321: rpc_register_blobServices(rpc_srv_t * __restrict srv)
                    322: {
                    323:        if (!srv)
                    324:                return -1;
                    325: 
                    326:        if (rpc_srv_registerCall(srv, CALL_BLOBSHUTDOWN, rpcBLOBServerShutdown) < 1)
                    327:                return -1;
                    328:        if (rpc_srv_registerCall(srv, CALL_BLOBCLIENTS, rpcBLOBServerClients) < 1)
                    329:                return -1;
                    330:        if (rpc_srv_registerCall(srv, CALL_BLOBVARS, rpcBLOBServerVars) < 1)
                    331:                return -1;
                    332: 
                    333:        return 0;
                    334: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>