Annotation of libaitrpc/src/builtin.c, revision 1.6.4.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.6.4.1 ! misho       6: * $Id: builtin.c,v 1.6 2012/03/15 01:55:33 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: 
                     51: int
1.4       misho      52: rpcServerClients(rpc_func_t *call, int ic, array_t *iv)
1.1       misho      53: {
1.2       misho      54:        rpc_srv_t *srv;
1.4       misho      55:        array_t *vals;
1.1       misho      56:        rpc_cli_t *cli;
                     57:        register int i;
1.4       misho      58:        int len;
1.3       misho      59:        const char *str = NULL;
1.4       misho      60:        char *val, wrk[INET6_ADDRSTRLEN];
1.1       misho      61: 
1.2       misho      62:        RPC_CALLBACK_CHECK_INPUT(call);
                     63:        if (!call->func_parent)
1.1       misho      64:                return -1;
                     65:        else
1.2       misho      66:                srv = call->func_parent;
                     67: 
1.4       misho      68:        rpc_srv_getVars(call, &vals);
                     69: 
                     70:        len = srv->srv_numcli * STRSIZ;
                     71:        if (!(val = malloc(len))) {
                     72:                LOGERR;
1.1       misho      73:                return -1;
1.4       misho      74:        } else
                     75:                memset(val, 0, len);
1.1       misho      76: 
1.4       misho      77:        for (i = 0, cli = srv->srv_clients; i < srv->srv_numcli; i++, cli++) {
1.5       misho      78:                if (!cli->cli_sa.sa.sa_family)
1.1       misho      79:                        continue;
                     80: 
1.5       misho      81:                switch (cli->cli_sa.sa.sa_family) {
1.3       misho      82:                        case AF_INET:
1.5       misho      83:                                str = inet_ntop(cli->cli_sa.sa.sa_family, &cli->cli_sa.sin.sin_addr, wrk, sizeof wrk);
1.3       misho      84:                                break;
                     85:                        case AF_INET6:
1.5       misho      86:                                str = inet_ntop(cli->cli_sa.sa.sa_family, &cli->cli_sa.sin6.sin6_addr, wrk, sizeof wrk);
1.3       misho      87:                                break;
                     88:                        case AF_LOCAL:
1.5       misho      89:                                str = cli->cli_sa.sun.sun_path;
1.3       misho      90:                                break;
1.1       misho      91:                }
1.2       misho      92:                if (str)
1.4       misho      93:                        strlcat(val, (char*) str, len);
1.2       misho      94:                else
1.4       misho      95:                        strlcat(val, "0.0.0.0", len);
                     96:                strlcat(val, " ", len);
1.1       misho      97:        }
                     98: 
1.4       misho      99:        AIT_SET_STR(io_array(vals, 0, ait_val_t*), val);
                    100:        free(val);
1.1       misho     101:        return 0;
                    102: }
                    103: 
                    104: int
1.4       misho     105: rpcServerCalls(rpc_func_t *call, int ic, array_t *iv)
1.1       misho     106: {
1.2       misho     107:        rpc_srv_t *srv;
1.4       misho     108:        array_t *vals;
1.1       misho     109:        rpc_func_t *f;
                    110:        register int i;
1.4       misho     111:        int len;
                    112:        char *val, str[MAXPATHLEN];
1.1       misho     113: 
1.2       misho     114:        RPC_CALLBACK_CHECK_INPUT(call);
                    115:        if (!call->func_parent)
1.1       misho     116:                return -1;
1.2       misho     117:        else
                    118:                srv = call->func_parent;
1.1       misho     119: 
                    120:        for (i = 0, f = srv->srv_funcs; f; i++, f = f->func_next);
1.4       misho     121:        len = i * STRSIZ;
                    122: 
                    123:        rpc_srv_getVars(call, &vals);
                    124: 
                    125:        if (!(val = malloc(len))) {
                    126:                LOGERR;
1.1       misho     127:                return -1;
1.4       misho     128:        } else
                    129:                memset(val, 0, len);
1.1       misho     130: 
1.4       misho     131:        for (f = srv->srv_funcs, i = 0; f; f = f->func_next) {
1.6       misho     132:                if (*AIT_GET_STR(&f->func_name)) {
1.3       misho     133:                        memset(str, 0, sizeof str);
1.6       misho     134:                        if (AIT_ISEMPTY(&f->func_file))
                    135:                                snprintf(str, sizeof str, "/*/%s(%d); ", 
                    136:                                                AIT_GET_STR(&f->func_name), io_arraySize(f->func_vars));
                    137:                        else
                    138:                                snprintf(str, sizeof str, "/%s/%s(%d); ", AIT_GET_STR(&f->func_file), 
                    139:                                                AIT_GET_STR(&f->func_name), io_arraySize(f->func_vars));
1.4       misho     140:                        strlcat(val, str, len);
1.1       misho     141:                }
                    142:        }
                    143: 
1.4       misho     144:        AIT_SET_STR(io_array(vals, 0, ait_val_t*), val);
                    145:        free(val);
1.1       misho     146:        return 0;
                    147: }
                    148: 
                    149: int
1.4       misho     150: rpcServerSessions(rpc_func_t *call, int ic, array_t *iv)
1.1       misho     151: {
1.2       misho     152:        rpc_srv_t *srv;
1.4       misho     153:        array_t *vals;
                    154:        ait_val_t *v;
1.1       misho     155: 
1.2       misho     156:        RPC_CALLBACK_CHECK_INPUT(call);
                    157:        if (!call->func_parent)
1.1       misho     158:                return -1;
1.2       misho     159:        else
                    160:                srv = call->func_parent;
1.1       misho     161: 
1.4       misho     162:        rpc_srv_getVars(call, &vals);
1.1       misho     163: 
1.4       misho     164:        v = io_array(vals, 0, ait_val_t*);
                    165:        AIT_SET_U8(v, srv->srv_session.sess_version);
                    166:        v = io_array(vals, 1, ait_val_t*);
                    167:        AIT_SET_U32(v, srv->srv_session.sess_program);
                    168:        v = io_array(vals, 2, ait_val_t*);
                    169:        AIT_SET_U32(v, srv->srv_session.sess_process);
                    170:        v = io_array(vals, 3, ait_val_t*);
                    171:        AIT_SET_I32(v, srv->srv_numcli);
1.1       misho     172: 
                    173:        return 0;
                    174: }
1.2       misho     175: 
                    176: int
1.4       misho     177: rpcServerShutdown(rpc_func_t *call, int ic, array_t *iv)
1.2       misho     178: {
                    179:        rpc_srv_t *srv;
                    180: 
                    181:        RPC_CALLBACK_CHECK_INPUT(call);
                    182:        if (!call->func_parent)
                    183:                return -1;
                    184:        else
                    185:                srv = call->func_parent;
                    186: 
1.3       misho     187:        srv->srv_kill = kill;
1.2       misho     188: 
                    189:        return 0;
                    190: }
                    191: 
                    192: // ----------------------------------------------------
                    193: 
                    194: int
1.4       misho     195: rpcBLOBServerShutdown(rpc_func_t *call, int ic, array_t *iv)
1.2       misho     196: {
                    197:        rpc_srv_t *srv;
                    198: 
                    199:        RPC_CALLBACK_CHECK_INPUT(call);
                    200:        if (!call->func_parent)
                    201:                return -1;
                    202:        else
                    203:                srv = call->func_parent;
                    204: 
1.3       misho     205:        srv->srv_blob.state = kill;
1.2       misho     206: 
                    207:        return 0;
                    208: }
                    209: 
                    210: int
1.4       misho     211: rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *iv)
1.2       misho     212: {
                    213:        rpc_srv_t *srv;
1.4       misho     214:        array_t *vals;
1.2       misho     215:        rpc_blob_t *b;
                    216:        register int i;
1.4       misho     217:        char *val, str[64];
                    218:        int len;
1.2       misho     219: 
                    220:        RPC_CALLBACK_CHECK_INPUT(call);
                    221:        if (!call->func_parent)
                    222:                return -1;
                    223:        else
                    224:                srv = call->func_parent;
                    225: 
1.4       misho     226:        rpc_srv_getVars(call, &vals);
                    227: 
                    228:        if (srv->srv_blob.state == kill) {
                    229:                AIT_SET_STR(io_array(vals, 0, ait_val_t*), "BLOB Server is killed");
                    230:                return 1;
                    231:        }
                    232:        if (srv->srv_blob.state == disable) {
                    233:                AIT_SET_STR(io_array(vals, 0, ait_val_t*), "BLOB Server is disabled");
                    234:                return 1;
                    235:        }
                    236: 
1.2       misho     237:        pthread_mutex_lock(&srv->srv_blob.mtx);
                    238:        for (i = 0, b = srv->srv_blob.blobs; b; i++, b = b->blob_next);
1.4       misho     239:        len = i * sizeof str;
                    240: 
                    241:        if (!len) {
                    242:                AIT_SET_STR(io_array(vals, 0, ait_val_t*), "");
1.2       misho     243:                pthread_mutex_unlock(&srv->srv_blob.mtx);
                    244:                return 0;
                    245:        }
                    246: 
1.4       misho     247:        if (!(val = malloc(len))) {
                    248:                LOGERR;
                    249:                pthread_mutex_unlock(&srv->srv_blob.mtx);
                    250:                return -1;
                    251:        } else
                    252:                memset(val, 0, len);
                    253: 
                    254:        for (b = srv->srv_blob.blobs, i = 0; b; i++, b = b->blob_next) {
                    255:                memset(str, 0, sizeof str);
                    256:                snprintf(str, sizeof str, "0x%0X(%lu)=%p ", b->blob_var, (u_long) b->blob_len, b->blob_data);
                    257:                strlcat(val, str, len);
                    258:        }
                    259: 
                    260:        AIT_SET_STR(io_array(vals, 0, ait_val_t*), val);
                    261:        free(val);
1.2       misho     262:        pthread_mutex_unlock(&srv->srv_blob.mtx);
                    263:        return 0;
                    264: }
                    265: 
                    266: int
1.4       misho     267: rpcBLOBServerState(rpc_func_t *call, int ic, array_t *iv)
1.2       misho     268: {
                    269:        rpc_srv_t *srv;
                    270: 
                    271:        RPC_CALLBACK_CHK_ARGS(call, ic);
                    272:        if (!call->func_parent)
                    273:                return -1;
                    274:        else
                    275:                srv = call->func_parent;
                    276: 
1.4       misho     277:        if (AIT_TYPE(io_array(iv, 0, ait_val_t*)) != i32)
1.2       misho     278:                return -1;
                    279: 
1.4       misho     280:        srv->srv_blob.state = AIT_GET_I32(io_array(iv, 0, ait_val_t*));
1.2       misho     281:        return 0;
                    282: }
                    283: 
                    284: int
1.4       misho     285: rpcBLOBServerClients(rpc_func_t *call, int ic, array_t *iv)
1.2       misho     286: {
                    287:        rpc_srv_t *srv;
1.4       misho     288:        array_t *vals;
1.2       misho     289:        rpc_cli_t *cli;
                    290:        register int i;
1.4       misho     291:        int len;
1.3       misho     292:        const char *str = NULL;
1.4       misho     293:        char *val, wrk[INET6_ADDRSTRLEN];
1.2       misho     294: 
                    295:        RPC_CALLBACK_CHECK_INPUT(call);
                    296:        if (!call->func_parent)
                    297:                return -1;
                    298:        else
                    299:                srv = call->func_parent;
                    300: 
1.4       misho     301:        rpc_srv_getVars(call, &vals);
                    302: 
                    303:        if (srv->srv_blob.state == kill) {
                    304:                AIT_SET_STR(io_array(vals, 0, ait_val_t*), "BLOB Server is killed");
                    305:                return 1;
                    306:        }
                    307:        if (srv->srv_blob.state == disable) {
                    308:                AIT_SET_STR(io_array(vals, 0, ait_val_t*), "BLOB Server is disabled");
                    309:                return 1;
                    310:        }
                    311: 
                    312:        len = srv->srv_numcli * STRSIZ;
                    313:        if (!(val = malloc(len))) {
                    314:                LOGERR;
1.2       misho     315:                return -1;
1.4       misho     316:        } else
                    317:                memset(val, 0, len);
1.2       misho     318: 
1.4       misho     319:        for (i = 0, cli = srv->srv_blob.clients; i < srv->srv_numcli; i++, cli++) {
1.5       misho     320:                if (!cli->cli_sa.sa.sa_family)
1.2       misho     321:                        continue;
                    322: 
1.5       misho     323:                switch (cli->cli_sa.sa.sa_family) {
1.3       misho     324:                        case AF_INET:
1.5       misho     325:                                str = inet_ntop(cli->cli_sa.sa.sa_family, &cli->cli_sa.sin.sin_addr, wrk, sizeof wrk);
1.3       misho     326:                                break;
                    327:                        case AF_INET6:
1.5       misho     328:                                str = inet_ntop(cli->cli_sa.sa.sa_family, &cli->cli_sa.sin6.sin6_addr, wrk, sizeof wrk);
1.3       misho     329:                                break;
                    330:                        case AF_LOCAL:
1.5       misho     331:                                str = cli->cli_sa.sun.sun_path;
1.3       misho     332:                                break;
1.2       misho     333:                }
                    334:                if (str)
1.4       misho     335:                        strlcat(val, (char*) str, len);
1.2       misho     336:                else
1.4       misho     337:                        strlcat(val, "0.0.0.0", len);
                    338:                strlcat(val, " ", len);
1.2       misho     339:        }
                    340: 
1.4       misho     341:        AIT_SET_STR(io_array(vals, 0, ait_val_t*), val);
                    342:        free(val);
1.2       misho     343:        return 0;
                    344: }

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