Annotation of libaitrpc/src/aitrpc.c, revision 1.15.6.2

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.15.6.2! misho       6: * $Id: aitrpc.c,v 1.15.6.1 2014/12/11 01:15:34 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.15      misho      15: Copyright 2004 - 2014
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: #pragma GCC visibility push(hidden)
                     50: 
                     51: int rpc_Errno;
                     52: char rpc_Error[STRSIZ];
                     53: 
1.7       misho      54: inline int
                     55: rpc_funcs_cmp(struct tagRPCFunc *a, struct tagRPCFunc *b)
                     56: {
                     57:        int ret;
                     58: 
                     59:        assert(a && b);
                     60: 
                     61:        ret = AIT_KEY(&a->func_name) - AIT_KEY(&b->func_name);
                     62: 
                     63:        if (ret < 0)
                     64:                return -1;
                     65:        else if (ret > 0)
                     66:                return 1;
                     67: 
                     68:        return ret;
                     69: }
                     70: 
                     71: AVL_GENERATE(tagRPCFuncs, tagRPCFunc, func_node, rpc_funcs_cmp);
                     72: 
1.1       misho      73: #pragma GCC visibility pop
                     74: 
                     75: // rpc_GetErrno() Get error code of last operation
1.10      misho      76: int
1.1       misho      77: rpc_GetErrno()
                     78: {
                     79:        return rpc_Errno;
                     80: }
                     81: 
                     82: // rpc_GetError() Get error text of last operation
1.10      misho      83: const char *
1.1       misho      84: rpc_GetError()
                     85: {
                     86:        return rpc_Error;
                     87: }
                     88: 
                     89: // rpc_SetErr() Set error to variables for internal use!!!
1.10      misho      90: void
1.1       misho      91: rpc_SetErr(int eno, char *estr, ...)
                     92: {
                     93:        va_list lst;
                     94: 
                     95:        rpc_Errno = eno;
1.8       misho      96:        memset(rpc_Error, 0, sizeof rpc_Error);
1.1       misho      97:        va_start(lst, estr);
1.8       misho      98:        vsnprintf(rpc_Error, sizeof rpc_Error, estr, lst);
1.1       misho      99:        va_end(lst);
                    100: }
                    101: 
                    102: 
1.4       misho     103: /*
1.6       misho     104:  * rpc_chkPktSession() - Check RPC session
1.5       misho     105:  *
1.4       misho     106:  * @p = packet session
                    107:  * @s = active session
1.6       misho     108:  * return: -1, 1, 2, 3 are errors or 0 ok
1.4       misho     109:  */
1.10      misho     110: int
1.4       misho     111: rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s)
                    112: {
                    113:        if (!p || !s)
                    114:                return -1;
                    115: 
                    116:        if (p->sess_version != s->sess_version)
                    117:                return 1;
1.9       misho     118:        if (p->sess_instance != s->sess_instance)
1.4       misho     119:                return 2;
                    120: 
                    121:        return 0;
                    122: }
                    123: 
                    124: /*
1.6       misho     125:  * rpc_addPktSession() - Prepare session into network format
1.5       misho     126:  *
1.4       misho     127:  * @p = packet session
1.6       misho     128:  * @s = host session
1.4       misho     129:  * return: -1 error or 0 ok
                    130:  */
1.10      misho     131: int
1.4       misho     132: rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s)
                    133: {
                    134:        if (!p || !s)
                    135:                return -1;
                    136: 
                    137:        p->sess_version = s->sess_version;
1.9       misho     138:        p->sess_instance = s->sess_instance;
1.4       misho     139: 
                    140:        return 0;
                    141: }
1.11      misho     142: 
                    143: /*
                    144:  * rpc_Read() - RPC read operation
                    145:  *
                    146:  * @sock = socket
                    147:  * @type = type of socket
                    148:  * @flags = receive flags
                    149:  * @sa = check client address, if you use udp protocol
                    150:  * @buf = buffer
                    151:  * @blen = buffer length
1.14      misho     152:  * return: -1 error, 0 EOF or or >0 readed bytes into buffer
1.11      misho     153:  */
                    154: ssize_t
                    155: rpc_Read(int sock, int type, int flags, sockaddr_t * __restrict sa, 
                    156:                u_char * __restrict buf, size_t blen)
                    157: {
                    158:        struct pollfd pfd;
                    159:        sockaddr_t sa2;
                    160:        socklen_t salen;
1.15.6.2! misho     161:        int ret = 0, len, cx = 0;
        !           162:        ait_val_t v = AIT_VAL_INIT;
        !           163:        struct ether_header *eh;
        !           164:        struct bpf_hdr *h;
        !           165:        ether_addr_t bcst = {{ [0 ... sizeof bcst - 1] = 0xff }};
        !           166: 
        !           167:        if (type == SOCK_BPF && sa) {
        !           168:                AIT_SET_BUF(&v, NULL, blen);
        !           169:                h = (struct bpf_hdr*) AIT_GET_BUF(&v);
        !           170:        }
1.11      misho     171: 
                    172:        pfd.fd = sock;
                    173:        pfd.events = POLLIN | POLLPRI;
                    174:        memset(buf, 0, blen);
                    175:        memset(&sa2, 0, sizeof sa2);
                    176:        salen = sa2.ss.ss_len = sizeof(sockaddr_t);
                    177: 
1.13      misho     178:        for (len = blen; len > 0; len -= ret, buf += ret) {
                    179:                if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                    180:                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                    181:                        if (ret)
1.11      misho     182:                                LOGERR;
1.13      misho     183:                        else
                    184:                                rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
1.15.6.2! misho     185:                        if (type == SOCK_BPF)
        !           186:                                AIT_FREE_VAL(&v);
1.13      misho     187:                        return -1;
                    188:                }
                    189:                if (type == SOCK_STREAM)
                    190:                        ret = recv(sock, buf, len, flags);
1.15.6.2! misho     191:                else if (type == SOCK_BPF && sa) {
        !           192:                        ret = read(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
        !           193:                        if (ret > 0) {
        !           194:                                ret -= h->bh_hdrlen;
        !           195:                                if (ret < h->bh_caplen || h->bh_caplen != h->bh_datalen || 
        !           196:                                                ret < ETHER_HDR_LEN + sizeof(struct tagRPCCall)) {
        !           197:                                        if (cx < 3) {
        !           198:                                                cx++;
        !           199:                                                ret ^= ret;
        !           200:                                                continue;       /* wait for known address */
        !           201:                                        } else {
        !           202:                                                AIT_FREE_VAL(&v);
        !           203:                                                return -1;
        !           204:                                        }
        !           205:                                }
        !           206:                                ret = h->bh_caplen;
        !           207:                                eh = (struct ether_header*) (AIT_GET_BUF(&v) + h->bh_hdrlen);
        !           208:                                ret -= ETHER_HDR_LEN;
        !           209:                                if (eh->ether_type != ntohs(RPC_DEFPORT)) {
        !           210:                                        if (cx < 3) {
        !           211:                                                cx++;
        !           212:                                                ret ^= ret;
        !           213:                                                continue;       /* wait for known address */
        !           214:                                        } else {
        !           215:                                                AIT_FREE_VAL(&v);
        !           216:                                                return -1;
        !           217:                                        }
        !           218:                                }
        !           219: #if 0
        !           220:                                else
        !           221:                                        e_getlinkbymac((const ether_addr_t*) eh->ether_shost, &sa2);
        !           222:                                if (sa && e_addrcmp(sa, &sa2, 0)) {
        !           223: #else
        !           224:                                if (!memcmp(bcst.octet, eh->ether_dhost, sizeof bcst) || 
        !           225:                                                !memcmp(bcst.octet, eh->ether_shost, sizeof bcst)) {
        !           226: #endif
        !           227:                                        if (cx < 3) {
        !           228:                                                cx++;
        !           229:                                                ret ^= ret;
        !           230:                                                continue;       /* wait for known address */
        !           231:                                        } else {
        !           232:                                                AIT_FREE_VAL(&v);
        !           233:                                                return -1;
        !           234:                                        }
        !           235:                                }
        !           236:                                memcpy(buf, (u_char*) (eh + 1), MIN(ret, len));
        !           237:                                AIT_FREE_VAL(&v);
        !           238:                                return ret;
        !           239:                        }
        !           240:                } else {
1.13      misho     241:                        ret = recvfrom(sock, buf, len, flags, &sa2.sa, &salen);
                    242:                        if (ret > -1 && sa && e_addrcmp(sa, &sa2, 42)) {
1.15.6.2! misho     243:                                ret ^= ret;
        !           244:                                continue;       /* wait for known address */
1.11      misho     245:                        }
                    246:                }
1.13      misho     247:                if (ret == -1) {
                    248:                        LOGERR;
1.15.6.2! misho     249:                        if (type == SOCK_BPF)
        !           250:                                AIT_FREE_VAL(&v);
1.13      misho     251:                        return -1;
                    252:                }
1.15.6.2! misho     253:                if (!ret) {     /* EOF */
        !           254:                        if (type == SOCK_BPF)
        !           255:                                AIT_FREE_VAL(&v);
1.14      misho     256:                        return 0;
1.15.6.2! misho     257:                }
1.11      misho     258:        }
1.13      misho     259:        ret = blen - len;
1.11      misho     260: 
1.15.6.2! misho     261:        if (type == SOCK_BPF)
        !           262:                AIT_FREE_VAL(&v);
1.11      misho     263:        return ret;
                    264: }
                    265: 
                    266: /*
                    267:  * rpc_Write() - RPC write operation
                    268:  *
                    269:  * @sock = socket
                    270:  * @type = type of socket
                    271:  * @flags = send flags
                    272:  * @sa = send to client address, if you use udp protocol
                    273:  * @buf = buffer
                    274:  * @blen = buffer length
1.14      misho     275:  * return: -1 error, 0 EOF or >0 written bytes into buffer
1.11      misho     276:  */
                    277: ssize_t
                    278: rpc_Write(int sock, int type, int flags, sockaddr_t * __restrict sa, 
                    279:                u_char * __restrict buf, size_t blen)
                    280: {
                    281:        struct pollfd pfd;
                    282:        int ret = 0, len = 0;
1.15.6.1  misho     283:        ait_val_t v = AIT_VAL_INIT;
                    284:        struct ether_header *eh;
                    285: 
                    286:        if (type == SOCK_BPF && sa) {
                    287:                AIT_SET_BUF(&v, NULL, blen + sizeof(struct ether_header));
                    288:                eh = (struct ether_header*) AIT_GET_BUF(&v);
                    289:                memcpy(eh->ether_dhost, LLADDR(&sa->sdl), ETHER_ADDR_LEN);
                    290:                eh->ether_type = htons(RPC_DEFPORT);
                    291:                memcpy(eh + 1, buf, blen);
                    292:                blen += sizeof(struct ether_header);
                    293:        }
1.11      misho     294: 
                    295:        pfd.fd = sock;
                    296:        pfd.events = POLLOUT;
1.13      misho     297:        for (len = blen; len > 0; len -= ret, buf += ret) {
                    298:                if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                    299:                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
1.14      misho     300: #if 0
1.13      misho     301:                        if (!ret)
                    302:                                continue;
1.14      misho     303: #endif
1.13      misho     304:                        if (ret > 0)
                    305:                                rpc_SetErr(EPIPE, "Disconnected RPC session\n");
                    306:                        else
1.11      misho     307:                                LOGERR;
1.15.6.1  misho     308:                        if (type == SOCK_BPF)
                    309:                                AIT_FREE_VAL(&v);
1.13      misho     310:                        return -1;
                    311:                }
                    312:                if (type == SOCK_STREAM)
                    313:                        ret = send(sock, buf, len, flags);
1.15.6.1  misho     314:                else if (type == SOCK_BPF && sa) {
                    315:                        ret = write(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                    316:                } else if (sa)
1.13      misho     317:                        ret = sendto(sock, buf, len, flags, &sa->sa, sa->sa.sa_len);
                    318:                else {
                    319:                        rpc_SetErr(EINVAL, "Invalid argument(s)!");
1.15.6.1  misho     320:                        if (type == SOCK_BPF)
                    321:                                AIT_FREE_VAL(&v);
1.13      misho     322:                        return -1;
                    323:                }
                    324:                if (ret == -1) {
                    325:                        LOGERR;
1.15.6.1  misho     326:                        if (type == SOCK_BPF)
                    327:                                AIT_FREE_VAL(&v);
1.13      misho     328:                        return -1;
1.11      misho     329:                }
1.15.6.1  misho     330:                if (!ret) {     /* EOF */
                    331:                        if (type == SOCK_BPF)
                    332:                                AIT_FREE_VAL(&v);
1.14      misho     333:                        return 0;
1.15.6.1  misho     334:                }
1.11      misho     335:        }
1.13      misho     336:        ret = blen - len;
                    337:        if (ret != blen) {
1.11      misho     338:                rpc_SetErr(EPROCUNAVAIL, "RPC request, should be send %d bytes, "
1.15.6.1  misho     339:                                "really sended %d bytes", blen, ret);
                    340:                if (type == SOCK_BPF)
                    341:                        AIT_FREE_VAL(&v);
1.11      misho     342:                return -1;
                    343:        }
                    344: 
1.15.6.1  misho     345:        if (type == SOCK_BPF)
                    346:                AIT_FREE_VAL(&v);
1.11      misho     347:        return ret;
                    348: }

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