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

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