/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
 * Portions of this source code were derived from Berkeley
 * 4.3 BSD under license from the Regents of the University of
 * California.
 */

/*
 * Client interface to broadcast service.
 *
 * The following is kludged-up support for simple rpc broadcasts.
 * Someday a large, complicated system will replace these routines.
 */

#include "mt.h"
#include "rpc_mt.h"
#include <string.h>
#include <strings.h>
#include <rpc/rpc.h>
#include <rpc/nettype.h>
#include <sys/poll.h>
#include <netdir.h>
#ifdef PORTMAP
#include <rpc/pmap_prot.h>
#endif
#ifdef RPC_DEBUG
#include <stdio.h>
#endif
#include <errno.h>
#include <syslog.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXBCAST 20     /* Max no of broadcasting transports */
#define INITTIME 4000   /* Time to wait initially */
#define WAITTIME 8000   /* Maximum time to wait */

int lowvers = 1;        /* by default, broadcast only version 2 over UDP */
#ifndef NETIDLEN
#define NETIDLEN 32
#endif

/*
 * If nettype is NULL, it broadcasts on all the available
 * datagram_n transports. May potentially lead to broadacst storms
 * and hence should be used with caution, care and courage.
 *
 * The current parameter xdr packet size is limited by the max tsdu
 * size of the transport. If the max tsdu size of any transport is
 * smaller than the parameter xdr packet, then broadcast is not
 * sent on that transport.
 *
 * Also, the packet size should be less the packet size of
 * the data link layer (for ethernet it is 1400 bytes).  There is
 * no easy way to find out the max size of the data link layer and
 * we are assuming that the args would be smaller than that.
 *
 * The result size has to be smaller than the transport tsdu size.
 *
 * If PORTMAP has been defined, we send two packets for UDP, one for
 * rpcbind and one for portmap. For those machines which support
 * both rpcbind and portmap, it will cause them to reply twice, and
 * also here it will get two responses ... inefficient and clumsy.
 */


enum clnt_stat
rpc_broadcast_exp(const rpcprog_t prog, const rpcvers_t vers,
    const rpcproc_t proc, const xdrproc_t xargs, caddr_t argsp,
    const xdrproc_t xresults, caddr_t resultsp, const resultproc_t eachresult,
    const int inittime, const int waittime, const char *netclass)
{
        enum clnt_stat  stat = RPC_SUCCESS; /* Return status */
        XDR             xdr_stream; /* XDR stream */
        XDR             *xdrs = &xdr_stream;
        struct rpc_msg  msg;    /* RPC message */
        struct timeval  t;
        char            *outbuf = NULL; /* Broadcast msg buffer */
        char            *inbuf = NULL; /* Reply buf */
        uint_t          maxbufsize = 0;
        AUTH            *sys_auth = authsys_create_default();
        int             i, j;
        void            *handle;
        char            uaddress[1024]; /* A self imposed limit */
        char            *uaddrp = uaddress;
        int             pmap_reply_flag; /* reply recvd from PORTMAP */
        /* An array of all the suitable broadcast transports */
        struct {
                int fd;         /* File descriptor */
                bool_t udp_flag;        /* this is udp */
                struct netconfig *nconf; /* Netconfig structure */
                uint_t asize;   /* Size of the addr buf */
                uint_t dsize;   /* Size of the data buf */
                struct netbuf raddr; /* Remote address */
                struct nd_addrlist *nal; /* Broadcast addrs */
        } fdlist[MAXBCAST];
        struct pollfd pfd[MAXBCAST];
        int             fdlistno = 0;
        struct r_rpcb_rmtcallargs barg; /* Remote arguments */
        struct r_rpcb_rmtcallres bres; /* Remote results */
        struct t_unitdata t_udata, t_rdata;
        struct netconfig *nconf;
        struct nd_hostserv hs;
        int msec;
        int pollretval;
        int fds_found;
        char nettype_array[NETIDLEN];
        char *nettype = &nettype_array[0];

#ifdef PORTMAP
        rpcport_t *port;        /* Remote port number */
        int pmap_flag = 0;      /* UDP exists ? */
        char *outbuf_pmap = NULL;
        struct p_rmtcallargs barg_pmap; /* Remote arguments */
        struct p_rmtcallres bres_pmap; /* Remote results */
        struct t_unitdata t_udata_pmap;
        int udpbufsz = 0;
#endif                          /* PORTMAP */

        if (sys_auth == NULL)
                return (RPC_SYSTEMERROR);
        /*
         * initialization: create a fd, a broadcast address, and send the
         * request on the broadcast transport.
         * Listen on all of them and on replies, call the user supplied
         * function.
         */

        if (netclass == NULL)
                nettype = NULL;
        else {
                size_t len = strlen(netclass);
                if (len >= sizeof (nettype_array))
                        return (RPC_UNKNOWNPROTO);
                (void) strcpy(nettype, netclass);
        }

        if (nettype == NULL)
                nettype = "datagram_n";
        if ((handle = __rpc_setconf((char *)nettype)) == NULL)
                return (RPC_UNKNOWNPROTO);
        while (nconf = __rpc_getconf(handle)) {
                struct t_info tinfo;
                int fd;
                uint_t addrlen;

                if (nconf->nc_semantics != NC_TPI_CLTS)
                        continue;
                if (fdlistno >= MAXBCAST)
                        break;  /* No more slots available */
                if ((fd = t_open(nconf->nc_device, O_RDWR, &tinfo)) == -1) {
                        stat = RPC_CANTSEND;
                        continue;
                }
                __rpc_set_mac_options(fd, nconf, prog);
                if (t_bind(fd, NULL, NULL) == -1) {
                        (void) t_close(fd);
                        stat = RPC_CANTSEND;
                        continue;
                }

                /* Do protocol specific negotiating for broadcast */
                if (netdir_options(nconf, ND_SET_BROADCAST, fd, NULL)) {
                        (void) t_close(fd);
                        stat = RPC_NOBROADCAST;
                        continue;
                }
                fdlist[fdlistno].fd = fd;
                fdlist[fdlistno].nconf = nconf;
                fdlist[fdlistno].udp_flag = FALSE;
                if (((addrlen = __rpc_get_a_size(tinfo.addr)) == 0) ||
                    ((fdlist[fdlistno].raddr.buf = malloc(addrlen)) == NULL)) {
                        (void) t_close(fd);
                        stat = RPC_SYSTEMERROR;
                        goto done_broad;
                }
                fdlist[fdlistno].raddr.maxlen = addrlen;
                fdlist[fdlistno].raddr.len = addrlen;
                pfd[fdlistno].events = POLLIN | POLLPRI |
                        POLLRDNORM | POLLRDBAND;
                pfd[fdlistno].fd = fdlist[fdlistno].fd = fd;
                fdlist[fdlistno].asize = addrlen;

                if ((fdlist[fdlistno].dsize = __rpc_get_t_size(0,
                                tinfo.tsdu)) == 0) {
                        (void) t_close(fd);
                        free(fdlist[fdlistno].raddr.buf);
                        stat = RPC_SYSTEMERROR; /* XXX */
                        goto done_broad;
                }

                if (maxbufsize <= fdlist[fdlistno].dsize)
                        maxbufsize = fdlist[fdlistno].dsize;
#ifdef PORTMAP
                if (strcmp(nconf->nc_protofmly, NC_INET) == 0 &&
                    strcmp(nconf->nc_proto, NC_UDP) == 0) {
                        udpbufsz = fdlist[fdlistno].dsize;
                        if ((outbuf_pmap = malloc(udpbufsz)) == NULL) {
                                (void) t_close(fd);
                                free(fdlist[fdlistno].raddr.buf);
                                stat = RPC_SYSTEMERROR;
                                goto done_broad;
                        }
                        pmap_flag = 1;
                        fdlist[fdlistno].udp_flag = TRUE;
                }
#endif
                fdlistno++;
        }

        if (fdlistno == 0) {
                if (stat == RPC_SUCCESS)
                        stat = RPC_UNKNOWNPROTO;
                goto done_broad;
        }
        if (maxbufsize == 0) {
                if (stat == RPC_SUCCESS)
                        stat = RPC_CANTSEND;
                goto done_broad;
        }
        inbuf = malloc((size_t)maxbufsize);
        outbuf = malloc((size_t)maxbufsize);
        if ((inbuf == NULL) || (outbuf == NULL)) {
                stat = RPC_SYSTEMERROR;
                goto done_broad;
        }

        /* Serialize all the arguments which have to be sent */
        (void) gettimeofday(&t, (struct timezone *)0);
        msg.rm_xid = getpid() ^ t.tv_sec ^ t.tv_usec;
        msg.rm_direction = CALL;
        msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
        msg.rm_call.cb_prog = RPCBPROG;
        msg.rm_call.cb_vers = RPCBVERS;
        msg.rm_call.cb_proc = RPCBPROC_CALLIT;
        barg.prog = prog;
        barg.vers = vers;
        barg.proc = proc;
        barg.args.args_val = argsp;
        barg.xdr_args = xargs;
        bres.addr = uaddrp;
        bres.results.results_val = resultsp;
        bres.xdr_res = xresults;
        msg.rm_call.cb_cred = sys_auth->ah_cred;
        msg.rm_call.cb_verf = sys_auth->ah_verf;
        xdrmem_create(xdrs, outbuf, maxbufsize, XDR_ENCODE);
        if ((!xdr_callmsg(xdrs, &msg)) ||
            (!xdr_rpcb_rmtcallargs(xdrs, &barg))) {
                stat = RPC_CANTENCODEARGS;
                goto done_broad;
        }
        t_udata.opt.len = 0;
        t_udata.udata.buf = outbuf;
        t_udata.udata.len = xdr_getpos(xdrs);
        t_udata.udata.maxlen = t_udata.udata.len;
        /* XXX Should have set opt to its legal maxlen. */
        t_rdata.opt.len = t_rdata.opt.maxlen = 0;
        xdr_destroy(xdrs);

#ifdef PORTMAP
        /* Prepare the packet for version 2 PORTMAP */
        if (pmap_flag) {
                msg.rm_xid++;   /* One way to distinguish */
                msg.rm_call.cb_prog = PMAPPROG;
                msg.rm_call.cb_vers = PMAPVERS;
                msg.rm_call.cb_proc = PMAPPROC_CALLIT;
                barg_pmap.prog = prog;
                barg_pmap.vers = vers;
                barg_pmap.proc = proc;
                barg_pmap.args.args_val = argsp;
                barg_pmap.xdr_args = xargs;
                port = &bres_pmap.port; /* for use later on */
                bres_pmap.xdr_res = xresults;
                bres_pmap.res.res_val = resultsp;
                xdrmem_create(xdrs, outbuf_pmap, udpbufsz, XDR_ENCODE);
                if ((!xdr_callmsg(xdrs, &msg)) ||
                    (!xdr_rmtcallargs(xdrs, &barg_pmap))) {
                        stat = RPC_CANTENCODEARGS;
                        goto done_broad;
                }
                t_udata_pmap.opt.len = 0;
                t_udata_pmap.udata.buf = outbuf_pmap;
                t_udata_pmap.udata.len = xdr_getpos(xdrs);
                xdr_destroy(xdrs);
        }
#endif                          /* PORTMAP */

        /*
         * Basic loop: broadcast the packets to transports which
         * support data packets of size such that one can encode
         * all the arguments.
         * Wait a while for response(s).
         * The response timeout grows larger per iteration.
         */
        hs.h_host = HOST_BROADCAST;
        hs.h_serv = "rpcbind";

        for (msec = inittime; msec <= waittime; msec += msec) {
                /* Broadcast all the packets now */
                for (i = 0; i < fdlistno; i++) {
                        if (strcmp(fdlist[i].nconf->nc_protofmly,
                            NC_INET6) == 0) {
                                /* if it's IPv6 */

                                struct netbuf addr;
                                struct sockaddr_in6 sa6;

                                /* fill in the multicast address */
                                bzero((char *)&sa6, sizeof (sa6));
                                sa6.sin6_family = AF_INET6;
                                sa6.sin6_port = htons(PMAPPORT);
                                (void) inet_pton(AF_INET6, RPCB_MULTICAST_ADDR,
                                        &sa6.sin6_addr);
                                addr.maxlen = sizeof (struct sockaddr_in6);
                                addr.len = addr.maxlen;
                                addr.buf = (char *)&sa6;

                                /* now send rpcbind message */
                                t_udata.addr = addr;


                                if (t_sndudata(fdlist[i].fd,
                                        &t_udata)) {
                                        (void) syslog(LOG_ERR,
                                        "Cannot send broadcast\
packet: %m");
#ifdef  RPC_DEBUG
                                t_error("rpc_broadcast: t_sndudata");
#endif
                                        stat = RPC_CANTSEND;
                                        continue;
                                }

                        } else {

                                struct nd_addrlist *addrlist;

                                if (fdlist[i].dsize < t_udata.udata.len) {
                                        stat = RPC_CANTSEND;
                                        continue;
                                }
                                if (netdir_getbyname(fdlist[i].nconf, &hs,
                                        &addrlist) || (addrlist->n_cnt == 0)) {
                                        stat = RPC_N2AXLATEFAILURE;
                                        continue;
                                }

                                for (j = 0; j < addrlist->n_cnt; j++) {
#ifdef  RPC_DEBUG
                                        struct netconfig *nconf =
                                                fdlist[i].nconf;
#endif

                                        t_udata.addr = addrlist->n_addrs[j];

                                        /*
                                         * Only use version 3 if lowvers
                                         * is not set or transport is not UDP.
                                         */

                                        if (!lowvers || !fdlist[i].udp_flag)
                                        if (t_sndudata(fdlist[i].fd,
                                                &t_udata)) {
                                                (void) syslog(LOG_ERR,
                                                "Cannot send broadcast\
packet: %m");
#ifdef  RPC_DEBUG
                                        t_error("rpc_broadcast: t_sndudata");
#endif
                                                        stat = RPC_CANTSEND;
                                                        continue;
                                                };
#ifdef  RPC_DEBUG
                                        if (!lowvers || !fdlist[i].udp_flag)
                                                fprintf(stderr, "Broadcast\
packet sent for %s\n", nconf->nc_netid);
#endif
#ifdef  PORTMAP
                                        /*
                                         * Send the version 2 packet also
                                         * for UDP/IP
                                         */
                                        if (fdlist[i].udp_flag) {
                                                t_udata_pmap.addr =
                                                        t_udata.addr;
                                                if (t_sndudata(fdlist[i].fd,
                                                        &t_udata_pmap)) {
                                                        (void) syslog(LOG_ERR,\
"Cannot send broadcast packet: %m");
#ifdef RPC_DEBUG
                                                t_error("rpc_broadcast:\
t_sndudata");
#endif
                                                stat = RPC_CANTSEND;
                                                continue;
                                                }
                                        }
#ifdef RPC_DEBUG
                                        fprintf(stderr, "PMAP Broadcast packet\
sent for %s\n", nconf->nc_netid);
#endif
#endif                          /* PORTMAP */
                                }
                        /* End for sending all packets on this transport */
                        (void) netdir_free((char *)addrlist, ND_ADDRLIST);
                        } /* end non-IPv6 */

                }               /* End for sending on all transports */

                if (eachresult == NULL) {
                        stat = RPC_SUCCESS;
                        goto done_broad;
                }

                /*
                 * Get all the replies from these broadcast requests
                 */
        recv_again:

                switch (pollretval = poll(pfd, fdlistno, msec)) {
                case 0:         /* timed out */
                        stat = RPC_TIMEDOUT;
                        continue;
                case -1:        /* some kind of error - we ignore it */
                        goto recv_again;
                }               /* end of poll results switch */

                t_rdata.udata.buf = inbuf;

                for (i = fds_found = 0;
                        i < fdlistno && fds_found < pollretval; i++) {

                        int flag;
                        bool_t  done = FALSE;

                        if (pfd[i].revents == 0)
                                continue;
                        else if (pfd[i].revents & POLLNVAL) {
                                /*
                                 * Something bad has happened to this descri-
                                 * ptor. We can cause poll() to ignore
                                 * it simply by using a negative fd.  We do that
                                 * rather than compacting the pfd[] and fdlist[]
                                 * arrays.
                                 */
                                pfd[i].fd = -1;
                                fds_found++;
                                continue;
                        } else
                                fds_found++;
#ifdef RPC_DEBUG
                        fprintf(stderr, "response for %s\n",
                                fdlist[i].nconf->nc_netid);
#endif
                try_again:
                        t_rdata.udata.maxlen = fdlist[i].dsize;
                        t_rdata.udata.len = 0;
                        t_rdata.addr = fdlist[i].raddr;
                        if (t_rcvudata(fdlist[i].fd, &t_rdata, &flag) == -1) {
                                if (t_errno == TSYSERR && errno == EINTR)
                                        goto try_again;

                                /*
                                 * Ignore any T_UDERR look errors.
                                 * We should never see any ICMP port
                                 * unreachables when broadcasting but it has
                                 * been observed with broken IP
                                 * implementations.
                                 */
                                if (t_errno == TLOOK &&
                                    t_look(fdlist[i].fd) == T_UDERR &&
                                    t_rcvuderr(fdlist[i].fd, NULL) == 0)
                                        goto recv_again;

                                (void) syslog(LOG_ERR,
                                        "Cannot receive reply to \
                                        broadcast: %m");
                                stat = RPC_CANTRECV;
                                continue;
                        }
                        /*
                         * Not taking care of flag for T_MORE.
                         * We are assuming that
                         * such calls should not take more than one
                         * transport packet.
                         */
                        if (flag & T_MORE)
                                continue; /* Drop that and go ahead */
                        if (t_rdata.udata.len < (uint_t)sizeof (uint32_t))
                                continue; /* Drop that and go ahead */
                        /*
                         * see if reply transaction id matches sent id.
                         * If so, decode the results. If return id is xid + 1
                         * it was a PORTMAP reply
                         */
                        /* LINTED pointer cast */
                        if (*((uint32_t *)(inbuf)) == *((uint32_t *)(outbuf))) {
                                pmap_reply_flag = 0;
                                msg.acpted_rply.ar_verf = _null_auth;
                                msg.acpted_rply.ar_results.where =
                                        (caddr_t)&bres;
                                msg.acpted_rply.ar_results.proc =
                                        (xdrproc_t)xdr_rpcb_rmtcallres;
#ifdef PORTMAP
                        } else if (pmap_flag &&
                                /* LINTED pointer cast */
                                *((uint32_t *)(inbuf)) ==
                                        /* LINTED pointer cast */
                                        *((uint32_t *)(outbuf_pmap))) {
                                pmap_reply_flag = 1;
                                msg.acpted_rply.ar_verf = _null_auth;
                                msg.acpted_rply.ar_results.where =
                                        (caddr_t)&bres_pmap;
                                msg.acpted_rply.ar_results.proc =
                                        (xdrproc_t)xdr_rmtcallres;
#endif                          /* PORTMAP */
                        } else
                                continue;
                        xdrmem_create(xdrs, inbuf,
                                (uint_t)t_rdata.udata.len, XDR_DECODE);
                        if (xdr_replymsg(xdrs, &msg)) {
                                if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
                                    (msg.acpted_rply.ar_stat == SUCCESS)) {
                                        struct netbuf *taddr;
#ifdef PORTMAP
                                        if (pmap_flag && pmap_reply_flag) {
                                                /* convert port to taddr */
                                                /* LINTED pointer cast */
                                                ((struct sockaddr_in *)
                                                t_rdata.addr.buf)->sin_port =
                                                htons((ushort_t)*port);
                                                taddr = &t_rdata.addr;
                                        } else /* Convert the uaddr to taddr */
#endif
                                                taddr = uaddr2taddr(
                                                    fdlist[i].nconf,
                                                    uaddrp);
                                        done = (*eachresult)(resultsp, taddr,
                                                fdlist[i].nconf);
#ifdef RPC_DEBUG
                                {
                                        int k;

                                        printf("rmt addr = ");
                                        for (k = 0; k < taddr->len; k++)
                                                printf("%d ", taddr->buf[k]);
                                        printf("\n");
                                }
#endif
                                        if (taddr && !pmap_reply_flag)
                                                netdir_free((char *)taddr,
                                                            ND_ADDR);
                                }
                                /* otherwise, we just ignore the errors ... */
                        }
                        /* else some kind of deserialization problem ... */

                        xdrs->x_op = XDR_FREE;
                        msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
                        (void) xdr_replymsg(xdrs, &msg);
                        (void) (*xresults)(xdrs, resultsp);
                        XDR_DESTROY(xdrs);
                        if (done) {
                                stat = RPC_SUCCESS;
                                goto done_broad;
                        } else {
                                if (rpc_callerr.re_status == RPC_SYSTEMERROR) {
                                        stat = RPC_SYSTEMERROR;
                                        goto done_broad;
                                }
                                goto recv_again;
                        }
                }               /* The recv for loop */
        }                       /* The giant for loop */

done_broad:
        if (inbuf)
                free(inbuf);
        if (outbuf)
                free(outbuf);
#ifdef PORTMAP
        if (outbuf_pmap)
                free(outbuf_pmap);
#endif
        for (i = 0; i < fdlistno; i++) {
                (void) t_close(fdlist[i].fd);
                free(fdlist[i].raddr.buf);
        }
        AUTH_DESTROY(sys_auth);
        (void) __rpc_endconf(handle);

        return (stat);
}

enum clnt_stat
rpc_broadcast(const rpcprog_t prog, const rpcvers_t vers, const rpcproc_t proc,
        const xdrproc_t xargs, caddr_t argsp, xdrproc_t const xresults,
        caddr_t resultsp, const resultproc_t eachresult, const char *nettype)
{
        return (rpc_broadcast_exp(prog, vers, proc, xargs, argsp,
                xresults, resultsp, eachresult,
                INITTIME, WAITTIME, nettype));
}